Attempt to modify buffered_queue to take ownership of a source rather than reference, other cleanup

Attempt to fix compile errors caused by make_shared with private constructor

Attempt to fix compile errors

Attempt to fix appearance of no characters in lexer

1 files changed, 356 insertions, 416 deletions

diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h
index 9ad2c4c..4c115b2 100644
--- a/gcc/rust/ast/rust-ast.h
+++ b/gcc/rust/ast/rust-ast.h
@@ -4,15 +4,12 @@
 
 // GCC imports
 #include "config.h"
-//#define INCLUDE_UNIQUE_PTR
-// should allow including the gcc emulation of std::unique_ptr
 #include "system.h"
-#include "coretypes.h" // order: config, INCLUDE, system, coretypes
+#include "coretypes.h" // order: config, system, coretypes
 
 #include "rust-system.h"
 
 // STL imports
-// with C++11, now can use actual std::unique_ptr
 #include <memory>
 #include <string>
 #include <vector>
@@ -25,9 +22,7 @@
 
 namespace Rust {
 // TODO: remove typedefs and make actual types for these
-// typedef int Location;
-// typedef ::std::string SimplePath;
-typedef ::std::string Identifier;
+typedef std::string Identifier;
 typedef int TupleIndex;
 
 struct Session;
@@ -59,7 +54,7 @@ enum DelimType
     }
 
     // Get node output as a string. Pure virtual.
-    virtual ::std::string as_string() const = 0;
+    virtual std::string as_string() const = 0;
 
     virtual ~Node() {}
 
@@ -79,19 +74,19 @@ public:
   virtual ~AttrInput () {}
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<AttrInput> clone_attr_input () const
+  std::unique_ptr<AttrInput> clone_attr_input () const
   {
-    return ::std::unique_ptr<AttrInput> (clone_attr_input_impl ());
+    return std::unique_ptr<AttrInput> (clone_attr_input_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
   virtual bool check_cfg_predicate (const Session &session) const = 0;
 
   // Parse attribute input to meta item, if possible
-  virtual AttrInput *parse_to_meta_item () const { return NULL; }
+  virtual AttrInput *parse_to_meta_item () const { return nullptr; }
 
 protected:
   // pure virtual clone implementation
@@ -108,19 +103,18 @@ public:
   virtual ~TokenTree () {}
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<TokenTree> clone_token_tree () const
+  std::unique_ptr<TokenTree> clone_token_tree () const
   {
-    return ::std::unique_ptr<TokenTree> (clone_token_tree_impl ());
+    return std::unique_ptr<TokenTree> (clone_token_tree_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
   /* Converts token tree to a flat token stream. Tokens must be pointer to avoid
    * mutual dependency with Token. */
-  virtual ::std::vector< ::std::unique_ptr<Token> >
-  to_token_stream () const = 0;
+  virtual std::vector<std::unique_ptr<Token>> to_token_stream () const = 0;
 
 protected:
   // pure virtual clone implementation
@@ -133,12 +127,12 @@ class MacroMatch
 public:
   virtual ~MacroMatch () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<MacroMatch> clone_macro_match () const
+  std::unique_ptr<MacroMatch> clone_macro_match () const
   {
-    return ::std::unique_ptr<MacroMatch> (clone_macro_match_impl ());
+    return std::unique_ptr<MacroMatch> (clone_macro_match_impl ());
   }
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
@@ -165,23 +159,23 @@ class Token : public TokenTree, public MacroMatch
 
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<Token> clone_token () const
+  std::unique_ptr<Token> clone_token () const
   {
-    return ::std::unique_ptr<Token> (clone_token_impl ());
+    return std::unique_ptr<Token> (clone_token_impl ());
   }
 
-  // constructor from general text - avoid using if lexer const_TokenPtr is
-  // available
-  Token (TokenId token_id, Location locus, ::std::string str,
+  /* constructor from general text - avoid using if lexer const_TokenPtr is
+   * available */
+  Token (TokenId token_id, Location locus, std::string str,
 	 PrimitiveCoreType type_hint)
-    : token_id (token_id), locus (locus), str (::std::move (str)),
+    : token_id (token_id), locus (locus), str (std::move (str)),
       type_hint (type_hint)
   {}
 
   // Constructor from lexer const_TokenPtr
-  /* TODO: find workaround for std::string being NULL - probably have to
+  /* TODO: find workaround for std::string being nullptr - probably have to
    * introduce new method in lexer Token, or maybe make conversion method
-   * there*/
+   * there */
   Token (const_TokenPtr lexer_token_ptr)
     : token_id (lexer_token_ptr->get_id ()),
       locus (lexer_token_ptr->get_locus ()), str (""),
@@ -213,7 +207,7 @@ public:
       }
   }
 
-  inline bool is_string_lit () const
+  bool is_string_lit () const
   {
     switch (token_id)
       {
@@ -225,13 +219,12 @@ public:
       }
   }
 
-  ::std::string as_string () const;
+  std::string as_string () const override;
 
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
+  void accept_vis (ASTVisitor &vis) override;
 
   // Return copy of itself but in token stream form.
-  virtual ::std::vector< ::std::unique_ptr<Token> >
-  to_token_stream () const OVERRIDE;
+  std::vector<std::unique_ptr<Token>> to_token_stream () const override;
 
   TokenId get_id () const { return token_id; }
 
@@ -241,18 +234,15 @@ protected:
   // No virtual for now as not polymorphic but can be in future
   /*virtual*/ Token *clone_token_impl () const { return new Token (*this); }
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual Token *clone_token_tree_impl () const OVERRIDE
-  {
-    return new Token (*this);
-  }
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  Token *clone_token_tree_impl () const override { return clone_token_impl (); }
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual Token *clone_macro_match_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  Token *clone_macro_match_impl () const override
   {
-    return new Token (*this);
+    return clone_token_impl ();
   }
 };
 
@@ -274,18 +264,18 @@ public:
   };
 
 private:
-  // TODO: maybe make subclasses of each type of literal with their typed values
-  // (or generics)
-  ::std::string value_as_string;
+  /* TODO: maybe make subclasses of each type of literal with their typed values
+   * (or generics) */
+  std::string value_as_string;
   LitType type;
 
 public:
-  ::std::string as_string () const { return value_as_string; }
+  std::string as_string () const { return value_as_string; }
 
-  inline LitType get_lit_type () const { return type; }
+  LitType get_lit_type () const { return type; }
 
-  Literal (::std::string value_as_string, LitType type)
-    : value_as_string (::std::move (value_as_string)), type (type)
+  Literal (std::string value_as_string, LitType type)
+    : value_as_string (std::move (value_as_string)), type (type)
   {}
 
   static Literal create_error () { return Literal ("", CHAR); }
@@ -298,50 +288,35 @@ public:
 class DelimTokenTree : public TokenTree, public AttrInput
 {
   DelimType delim_type;
-  ::std::vector< ::std::unique_ptr<TokenTree> > token_trees;
-
+  std::vector<std::unique_ptr<TokenTree>> token_trees;
   Location locus;
 
-  // TODO: move all the "parse" functions into a separate class that has the
-  // token stream reference - will be cleaner Parse a meta item inner.
-  //::std::unique_ptr<MetaItemInner> parse_meta_item_inner(const ::std::vector<
-  //::std::unique_ptr<Token> >& token_stream, int& i) const; SimplePath
-  // parse_simple_path(const ::std::vector< ::std::unique_ptr<Token> >&
-  // token_stream, int& i) const; SimplePathSegment
-  // parse_simple_path_segment(const ::std::vector<
-  // ::std::unique_ptr<Token> >& token_stream, int& i) const;
-  //::std::unique_ptr<MetaItemLitExpr> parse_meta_item_lit(const
-  //::std::unique_ptr<Token>&
-  // tok) const;
-  //::std::vector< ::std::unique_ptr<MetaItemInner> > parse_meta_item_seq(const
-  //::std::vector< ::std::unique_ptr<Token> >& token_stream, int& i) const;
-  // Literal
-  // parse_literal(const ::std::unique_ptr<Token>& tok) const;
-  //::std::unique_ptr<MetaItem> parse_path_meta_item(const ::std::vector<
-  //::std::unique_ptr<Token> >& token_stream, int& i) const; bool
-  // is_end_meta_item_tok(TokenId tok) const;
-
 protected:
-  // Use covariance to implement clone function as returning a DelimTokenTree
-  // object
-  virtual DelimTokenTree *clone_attr_input_impl () const OVERRIDE
+  DelimTokenTree *clone_delim_tok_tree_impl () const
   {
     return new DelimTokenTree (*this);
   }
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual DelimTokenTree *clone_token_tree_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning a DelimTokenTree
+   * object */
+  DelimTokenTree *clone_attr_input_impl () const override
   {
-    return new DelimTokenTree (*this);
+    return clone_delim_tok_tree_impl ();
+  }
+
+  /* Use covariance to implement clone function as returning a DelimTokenTree
+   * object */
+  DelimTokenTree *clone_token_tree_impl () const override
+  {
+    return clone_delim_tok_tree_impl ();
   }
 
 public:
   DelimTokenTree (DelimType delim_type,
-		  ::std::vector< ::std::unique_ptr<TokenTree> > token_trees
-		  = ::std::vector< ::std::unique_ptr<TokenTree> > (),
+		  std::vector<std::unique_ptr<TokenTree>> token_trees
+		  = std::vector<std::unique_ptr<TokenTree>> (),
 		  Location locus = Location ())
-    : delim_type (delim_type), token_trees (::std::move (token_trees)),
+    : delim_type (delim_type), token_trees (std::move (token_trees)),
       locus (locus)
   {}
 
@@ -349,14 +324,9 @@ public:
   DelimTokenTree (DelimTokenTree const &other)
     : delim_type (other.delim_type), locus (other.locus)
   {
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     token_trees.reserve (other.token_trees.size ());
-
     for (const auto &e : other.token_trees)
-      {
-	token_trees.push_back (e->clone_token_tree ());
-      }
+      token_trees.push_back (e->clone_token_tree ());
   }
 
   // overloaded assignment operator with vector clone
@@ -365,14 +335,9 @@ public:
     delim_type = other.delim_type;
     locus = other.locus;
 
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     token_trees.reserve (other.token_trees.size ());
-
     for (const auto &e : other.token_trees)
-      {
-	token_trees.push_back (e->clone_token_tree ());
-      }
+      token_trees.push_back (e->clone_token_tree ());
 
     return *this;
   }
@@ -383,35 +348,39 @@ public:
 
   static DelimTokenTree create_empty () { return DelimTokenTree (PARENS); }
 
-  ::std::string as_string () const;
+  std::string as_string () const override;
 
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
+  void accept_vis (ASTVisitor &vis) override;
 
-  virtual bool
-  check_cfg_predicate (const Session &session ATTRIBUTE_UNUSED) const OVERRIDE
+  bool
+  check_cfg_predicate (const Session &session ATTRIBUTE_UNUSED) const override
   {
     // this should never be called - should be converted first
     return false;
   }
 
-  virtual AttrInput *parse_to_meta_item () const OVERRIDE;
+  AttrInput *parse_to_meta_item () const override;
+
+  std::vector<std::unique_ptr<Token>> to_token_stream () const override;
 
-  virtual ::std::vector< ::std::unique_ptr<Token> >
-  to_token_stream () const OVERRIDE;
+  std::unique_ptr<DelimTokenTree> clone_delim_token_tree () const
+  {
+    return std::unique_ptr<DelimTokenTree> (clone_delim_tok_tree_impl ());
+  }
 };
 
-// Forward decl - definition moved to rust-expr.h as it requires LiteralExpr to
-// be defined
+/* Forward decl - definition moved to rust-expr.h as it requires LiteralExpr to
+ * be defined */
 class AttrInputLiteral;
 
-// TODO: move applicable stuff into here or just don't include it because
-// nothing uses it A segment of a path (maybe)
+/* TODO: move applicable stuff into here or just don't include it because
+ * nothing uses it A segment of a path (maybe) */
 class PathSegment
 {
 public:
   virtual ~PathSegment () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   // TODO: add visitor here?
 };
@@ -419,29 +388,29 @@ public:
 // A segment of a simple path without generic or type arguments
 class SimplePathSegment : public PathSegment
 {
-  ::std::string segment_name;
+  std::string segment_name;
   Location locus;
 
   // only allow identifiers, "super", "self", "crate", or "$crate"
 public:
   // TODO: put checks in constructor to enforce this rule?
-  SimplePathSegment (::std::string segment_name, Location locus = Location ())
-    : segment_name (::std::move (segment_name)), locus (locus)
+  SimplePathSegment (std::string segment_name, Location locus = Location ())
+    : segment_name (std::move (segment_name)), locus (locus)
   {}
 
-  // Returns whether simple path segment is in an invalid state (currently, if
-  // empty).
-  inline bool is_error () const { return segment_name.empty (); }
+  /* Returns whether simple path segment is in an invalid state (currently, if
+   * empty). */
+  bool is_error () const { return segment_name.empty (); }
 
   // Creates an error SimplePathSegment
   static SimplePathSegment create_error ()
   {
-    return SimplePathSegment (::std::string (""));
+    return SimplePathSegment (std::string (""));
   }
 
-  ::std::string as_string () const;
+  std::string as_string () const override;
 
-  inline Location get_locus () const { return locus; }
+  Location get_locus () const { return locus; }
 
   // TODO: visitor pattern?
 };
@@ -450,35 +419,35 @@ public:
 class SimplePath
 {
   bool has_opening_scope_resolution;
-  ::std::vector<SimplePathSegment> segments;
+  std::vector<SimplePathSegment> segments;
   Location locus;
 
 public:
   // Constructor
-  SimplePath (::std::vector<SimplePathSegment> path_segments,
+  SimplePath (std::vector<SimplePathSegment> path_segments,
 	      bool has_opening_scope_resolution = false,
 	      Location locus = Location ())
     : has_opening_scope_resolution (has_opening_scope_resolution),
-      segments (::std::move (path_segments)), locus (locus)
+      segments (std::move (path_segments)), locus (locus)
   {}
 
   // Creates an empty SimplePath.
   static SimplePath create_empty ()
   {
-    return SimplePath (::std::vector<SimplePathSegment> ());
+    return SimplePath (std::vector<SimplePathSegment> ());
   }
 
   // Returns whether the SimplePath is empty, i.e. has path segments.
-  inline bool is_empty () const { return segments.empty (); }
+  bool is_empty () const { return segments.empty (); }
 
-  ::std::string as_string () const;
+  std::string as_string () const;
 
   Location get_locus () const { return locus; }
 
   // does this need visitor if not polymorphic? probably not
 
   // path-to-string comparison operator
-  bool operator== (const ::std::string &rhs)
+  bool operator== (const std::string &rhs)
   {
     return !has_opening_scope_resolution && segments.size () == 1
 	   && segments[0].as_string () == rhs;
@@ -488,11 +457,11 @@ public:
    * ensure that this is a valid identifier in path, so be careful. Also, this
    * will have no location data.
    * TODO have checks? */
-  static SimplePath from_str (::std::string str)
+  static SimplePath from_str (std::string str)
   {
-    ::std::vector<AST::SimplePathSegment> single_segments
-      = {AST::SimplePathSegment (::std::move (str))};
-    return SimplePath (::std::move (single_segments));
+    std::vector<AST::SimplePathSegment> single_segments
+      = {AST::SimplePathSegment (std::move (str))};
+    return SimplePath (std::move (single_segments));
   }
 };
 
@@ -504,8 +473,7 @@ private:
   SimplePath path;
 
   // bool has_attr_input;
-  // AttrInput* attr_input;
-  ::std::unique_ptr<AttrInput> attr_input;
+  std::unique_ptr<AttrInput> attr_input;
 
   Location locus;
 
@@ -513,37 +481,33 @@ private:
 
 public:
   // Returns whether Attribute has AttrInput
-  inline bool has_attr_input () const { return attr_input != NULL; }
+  bool has_attr_input () const { return attr_input != nullptr; }
 
   // Constructor has pointer AttrInput for polymorphism reasons
-  Attribute (SimplePath path, ::std::unique_ptr<AttrInput> input,
+  Attribute (SimplePath path, std::unique_ptr<AttrInput> input,
 	     Location locus = Location ())
-    : path (::std::move (path)), attr_input (::std::move (input)), locus (locus)
+    : path (std::move (path)), attr_input (std::move (input)), locus (locus)
   {}
 
+  // default destructor
+  ~Attribute () = default;
+
   // Copy constructor must deep copy attr_input as unique pointer
   Attribute (Attribute const &other) : path (other.path), locus (other.locus)
   {
     // guard to protect from null pointer dereference
-    if (other.attr_input != NULL)
-      {
-	attr_input = other.attr_input->clone_attr_input ();
-      }
+    if (other.attr_input != nullptr)
+      attr_input = other.attr_input->clone_attr_input ();
   }
 
-  // default destructor
-  ~Attribute () = default;
-
   // overload assignment operator to use custom clone method
   Attribute &operator= (Attribute const &other)
   {
     path = other.path;
     locus = other.locus;
     // guard to protect from null pointer dereference
-    if (other.attr_input != NULL)
-      {
-	attr_input = other.attr_input->clone_attr_input ();
-      }
+    if (other.attr_input != nullptr)
+      attr_input = other.attr_input->clone_attr_input ();
 
     return *this;
   }
@@ -553,26 +517,19 @@ public:
   Attribute &operator= (Attribute &&other) = default;
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<Attribute> clone_attribute () const
+  std::unique_ptr<Attribute> clone_attribute () const
   {
-    return ::std::unique_ptr<Attribute> (clone_attribute_impl ());
+    return std::unique_ptr<Attribute> (clone_attribute_impl ());
   }
 
-  /*~Attribute() {
-      delete attr_input;
-  }*/
-
   // Creates an empty attribute (which is invalid)
   static Attribute create_empty ()
   {
-    return Attribute (SimplePath::create_empty (), NULL);
+    return Attribute (SimplePath::create_empty (), nullptr);
   }
 
   // Returns whether the attribute is considered an "empty" attribute.
-  inline bool is_empty () const
-  {
-    return attr_input == NULL && path.is_empty ();
-  }
+  bool is_empty () const { return attr_input == nullptr && path.is_empty (); }
 
   /* e.g.:
       #![crate_type = "lib"]
@@ -626,7 +583,7 @@ public:
    *   windows_subsystem
    *   feature     */
 
-  ::std::string as_string () const;
+  std::string as_string () const;
 
   // TODO: does this require visitor pattern as not polymorphic?
 
@@ -636,17 +593,15 @@ public:
   // Call to parse attribute body to meta item syntax.
   void parse_attr_to_meta_item ();
 
-  // Determines whether cfg predicate is true and item with attribute should not
-  // be stripped.
+  /* Determines whether cfg predicate is true and item with attribute should not
+   * be stripped. */
   bool check_cfg_predicate (const Session &session)
   {
-    // assume that cfg predicate actually can exist, i.e. attribute has cfg or
-    // cfg_attr path
+    /* assume that cfg predicate actually can exist, i.e. attribute has cfg or
+     * cfg_attr path */
 
     if (!has_attr_input ())
-      {
-	return false;
-      }
+      return false;
 
     // TODO: maybe replace with storing a "has been parsed" variable?
     parse_attr_to_meta_item ();
@@ -675,20 +630,20 @@ protected:
 
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<MetaItemInner> clone_meta_item_inner () const
+  std::unique_ptr<MetaItemInner> clone_meta_item_inner () const
   {
-    return ::std::unique_ptr<MetaItemInner> (clone_meta_item_inner_impl ());
+    return std::unique_ptr<MetaItemInner> (clone_meta_item_inner_impl ());
   }
 
   virtual ~MetaItemInner () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
-  // HACK: used to simplify parsing - creates a copy of that type, or returns
-  // null
-  virtual MetaNameValueStr *to_meta_name_value_str () const { return NULL; }
+  /* HACK: used to simplify parsing - creates a copy of that type, or returns
+   * null */
+  virtual MetaNameValueStr *to_meta_name_value_str () const { return nullptr; }
 
   // HACK: used to simplify parsing - same thing
   virtual SimplePath to_path_item () const
@@ -702,63 +657,67 @@ public:
 // Container used to store MetaItems as AttrInput (bridge-ish kinda thing)
 class AttrInputMetaItemContainer : public AttrInput
 {
-  ::std::vector< ::std::unique_ptr<MetaItemInner> > items;
+  std::vector<std::unique_ptr<MetaItemInner>> items;
 
 public:
   AttrInputMetaItemContainer (
-    ::std::vector< ::std::unique_ptr<MetaItemInner> > items)
-    : items (::std::move (items))
+    std::vector<std::unique_ptr<MetaItemInner>> items)
+    : items (std::move (items))
   {}
 
+  // no destructor definition required
+
+  // default move constructors
+  AttrInputMetaItemContainer (AttrInputMetaItemContainer &&other) = default;
+  AttrInputMetaItemContainer &operator= (AttrInputMetaItemContainer &&other)
+    = default;
+
+  std::string as_string () const override;
+
+  void accept_vis (ASTVisitor &vis) override;
+
+  bool check_cfg_predicate (const Session &session) const override;
+
+  // Clones this object.
+  std::unique_ptr<AttrInputMetaItemContainer>
+  clone_attr_input_meta_item_container () const
+  {
+    return std::unique_ptr<AttrInputMetaItemContainer> (
+      clone_attr_input_meta_item_container_impl ());
+  }
+
+protected:
+  // Use covariance to implement clone function as returning this type
+  AttrInputMetaItemContainer *clone_attr_input_impl () const override
+  {
+    return clone_attr_input_meta_item_container_impl ();
+  }
+
+  AttrInputMetaItemContainer *clone_attr_input_meta_item_container_impl () const
+  {
+    return new AttrInputMetaItemContainer (*this);
+  }
+
   // copy constructor with vector clone
   AttrInputMetaItemContainer (const AttrInputMetaItemContainer &other)
   {
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     items.reserve (other.items.size ());
-
     for (const auto &e : other.items)
-      {
-	items.push_back (e->clone_meta_item_inner ());
-      }
+      items.push_back (e->clone_meta_item_inner ());
   }
 
-  // no destructor definition required
-
   // copy assignment operator with vector clone
   AttrInputMetaItemContainer &
   operator= (const AttrInputMetaItemContainer &other)
   {
     AttrInput::operator= (other);
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
-    items.reserve (other.items.size ());
 
+    items.reserve (other.items.size ());
     for (const auto &e : other.items)
-      {
-	items.push_back (e->clone_meta_item_inner ());
-      }
+      items.push_back (e->clone_meta_item_inner ());
 
     return *this;
   }
-
-  // default move constructors
-  AttrInputMetaItemContainer (AttrInputMetaItemContainer &&other) = default;
-  AttrInputMetaItemContainer &operator= (AttrInputMetaItemContainer &&other)
-    = default;
-
-  ::std::string as_string () const OVERRIDE;
-
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
-
-  virtual bool check_cfg_predicate (const Session &session) const OVERRIDE;
-
-protected:
-  // Use covariance to implement clone function as returning this type
-  virtual AttrInputMetaItemContainer *clone_attr_input_impl () const OVERRIDE
-  {
-    return new AttrInputMetaItemContainer (*this);
-  }
 };
 
 // abstract base meta item class
@@ -793,19 +752,19 @@ class Stmt
 {
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<Stmt> clone_stmt () const
+  std::unique_ptr<Stmt> clone_stmt () const
   {
-    return ::std::unique_ptr<Stmt> (clone_stmt_impl ());
+    return std::unique_ptr<Stmt> (clone_stmt_impl ());
   }
 
   virtual ~Stmt () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
-  // HACK: slow way of getting location from base expression through virtual
-  // methods.
+  /* HACK: slow way of getting location from base expression through virtual
+   * methods. */
   virtual Location get_locus_slow () const { return Location (); }
 
 protected:
@@ -816,31 +775,31 @@ protected:
 // Rust "item" AST node (declaration of top-level/module-level allowed stuff)
 class Item : public Stmt
 {
-  ::std::vector<Attribute> outer_attrs;
+  std::vector<Attribute> outer_attrs;
 
   // TODO: should outer attrs be defined here or in each derived class?
 
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<Item> clone_item () const
+  std::unique_ptr<Item> clone_item () const
   {
-    return ::std::unique_ptr<Item> (clone_item_impl ());
+    return std::unique_ptr<Item> (clone_item_impl ());
   }
 
-  ::std::string as_string () const;
+  std::string as_string () const;
 
-  // Adds crate names to the vector passed by reference, if it can
-  // (polymorphism).
+  /* Adds crate names to the vector passed by reference, if it can
+   * (polymorphism). */
   virtual void
-  add_crate_name (::std::vector< ::std::string> &names ATTRIBUTE_UNUSED) const
+  add_crate_name (std::vector<std::string> &names ATTRIBUTE_UNUSED) const
   {}
 
   virtual void accept_vis (ASTVisitor &vis ATTRIBUTE_UNUSED) {}
 
 protected:
   // Constructor
-  Item (::std::vector<Attribute> outer_attribs = ::std::vector<Attribute> ())
-    : outer_attrs (::std::move (outer_attribs))
+  Item (std::vector<Attribute> outer_attribs = std::vector<Attribute> ())
+    : outer_attrs (std::move (outer_attribs))
   {}
 
   // Clone function implementation as pure virtual method
@@ -849,7 +808,7 @@ protected:
   /* Save having to specify two clone methods in derived classes by making
    * statement clone return item clone. Hopefully won't affect performance too
    * much. */
-  virtual Item *clone_stmt_impl () const OVERRIDE { return clone_item_impl (); }
+  Item *clone_stmt_impl () const override { return clone_item_impl (); }
 };
 
 // forward decl of ExprWithoutBlock
@@ -859,18 +818,15 @@ class ExprWithoutBlock;
 class Expr
 {
   // TODO: move outer attribute data to derived classes?
-  ::std::vector<Attribute> outer_attrs;
+  std::vector<Attribute> outer_attrs;
 
 public:
-  inline const ::std::vector<Attribute> &get_outer_attrs () const
-  {
-    return outer_attrs;
-  }
+  const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<Expr> clone_expr () const
+  std::unique_ptr<Expr> clone_expr () const
   {
-    return ::std::unique_ptr<Expr> (clone_expr_impl ());
+    return std::unique_ptr<Expr> (clone_expr_impl ());
   }
 
   /* TODO: public methods that could be useful:
@@ -878,33 +834,25 @@ public:
    * for some?
    *  - evaluate() - evaluates expression if constant? can_evaluate()? */
 
-  // HACK: downcasting without dynamic_cast (if possible) via polymorphism -
-  // overrided in subclasses of ExprWithoutBlock
-  virtual ExprWithoutBlock *as_expr_without_block () const
-  {
-    // DEBUG
-    fprintf (
-      stderr,
-      "clone expr without block returns null and has not been overriden\n");
-
-    return NULL;
-  }
+  /* HACK: downcasting without dynamic_cast (if possible) via polymorphism -
+   * overrided in subclasses of ExprWithoutBlock */
+  virtual ExprWithoutBlock *as_expr_without_block () const { return nullptr; }
 
   // TODO: make pure virtual if move out outer attributes to derived classes
-  virtual ::std::string as_string () const;
+  virtual std::string as_string () const;
 
   virtual ~Expr () {}
 
-  // HACK: slow way of getting location from base expression through virtual
-  // methods.
+  /* HACK: slow way of getting location from base expression through virtual
+   * methods. */
   virtual Location get_locus_slow () const { return Location (); }
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
 protected:
   // Constructor
-  Expr (::std::vector<Attribute> outer_attribs = ::std::vector<Attribute> ())
-    : outer_attrs (::std::move (outer_attribs))
+  Expr (std::vector<Attribute> outer_attribs = std::vector<Attribute> ())
+    : outer_attrs (std::move (outer_attribs))
   {}
 
   // Clone function implementation as pure virtual method
@@ -912,9 +860,9 @@ protected:
 
   // TODO: think of less hacky way to implement this kind of thing
   // Sets outer attributes.
-  void set_outer_attrs (::std::vector<Attribute> outer_attrs_to_set)
+  void set_outer_attrs (std::vector<Attribute> outer_attrs_to_set)
   {
-    outer_attrs = ::std::move (outer_attrs_to_set);
+    outer_attrs = std::move (outer_attrs_to_set);
   }
 };
 
@@ -923,45 +871,41 @@ class ExprWithoutBlock : public Expr
 {
 protected:
   // Constructor
-  ExprWithoutBlock (::std::vector<Attribute> outer_attribs
-		    = ::std::vector<Attribute> ())
-    : Expr (::std::move (outer_attribs))
+  ExprWithoutBlock (std::vector<Attribute> outer_attribs
+		    = std::vector<Attribute> ())
+    : Expr (std::move (outer_attribs))
   {}
 
   // pure virtual clone implementation
   virtual ExprWithoutBlock *clone_expr_without_block_impl () const = 0;
 
   /* Save having to specify two clone methods in derived classes by making expr
-   * clone
-   * return exprwithoutblock clone. Hopefully won't affect performance too much.
-   */
-  virtual ExprWithoutBlock *clone_expr_impl () const OVERRIDE
+   * clone return exprwithoutblock clone. Hopefully won't affect performance too
+   * much. */
+  ExprWithoutBlock *clone_expr_impl () const override
   {
     return clone_expr_without_block_impl ();
   }
 
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<ExprWithoutBlock> clone_expr_without_block () const
+  std::unique_ptr<ExprWithoutBlock> clone_expr_without_block () const
   {
-    return ::std::unique_ptr<ExprWithoutBlock> (
-      clone_expr_without_block_impl ());
+    return std::unique_ptr<ExprWithoutBlock> (clone_expr_without_block_impl ());
   }
 
-  // downcasting hack from expr to use pratt parsing with
-  // parse_expr_without_block
-  virtual ExprWithoutBlock *as_expr_without_block () const OVERRIDE
+  /* downcasting hack from expr to use pratt parsing with
+   * parse_expr_without_block */
+  ExprWithoutBlock *as_expr_without_block () const override
   {
-    // DEBUG
-    fprintf (stderr, "about to call the impl for clone expr without block\n");
-
     return clone_expr_without_block_impl ();
   }
 };
 
-// HACK: IdentifierExpr, delete when figure out identifier vs expr problem in
-// Pratt parser Alternatively, identifiers could just be represented as
-// single-segment paths
+/* HACK: IdentifierExpr, delete when figure out identifier vs expr problem in
+ * Pratt parser */
+/* Alternatively, identifiers could just be represented as single-segment paths
+ */
 class IdentifierExpr : public ExprWithoutBlock
 {
 public:
@@ -970,26 +914,39 @@ public:
   Location locus;
 
   IdentifierExpr (Identifier ident, Location locus = Location (),
-		  ::std::vector<Attribute> outer_attrs
-		  = ::std::vector<Attribute> ())
-    : ExprWithoutBlock (::std::move (outer_attrs)), ident (::std::move (ident)),
+		  std::vector<Attribute> outer_attrs
+		  = std::vector<Attribute> ())
+    : ExprWithoutBlock (std::move (outer_attrs)), ident (std::move (ident)),
       locus (locus)
   {}
 
-  ::std::string as_string () const OVERRIDE { return ident; }
+  std::string as_string () const override { return ident; }
 
   Location get_locus () const { return locus; }
+  Location get_locus_slow () const override { return get_locus (); }
 
-  Location get_locus_slow () const OVERRIDE { return get_locus (); }
+  void accept_vis (ASTVisitor &vis) override;
 
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
+  // Clones this object.
+  std::unique_ptr<IdentifierExpr> clone_identifier_expr () const
+  {
+    return std::unique_ptr<IdentifierExpr> (clone_identifier_expr_impl ());
+  }
 
 protected:
   // Clone method implementation
-  virtual IdentifierExpr *clone_expr_without_block_impl () const OVERRIDE
+  IdentifierExpr *clone_expr_without_block_impl () const override
+  {
+    return clone_identifier_expr_impl ();
+  }
+
+  IdentifierExpr *clone_identifier_expr_impl () const
   {
     return new IdentifierExpr (*this);
   }
+
+  IdentifierExpr (IdentifierExpr const &other) = default;
+  IdentifierExpr &operator= (IdentifierExpr const &other) = default;
 };
 
 // Pattern base AST node
@@ -997,16 +954,16 @@ class Pattern
 {
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<Pattern> clone_pattern () const
+  std::unique_ptr<Pattern> clone_pattern () const
   {
-    return ::std::unique_ptr<Pattern> (clone_pattern_impl ());
+    return std::unique_ptr<Pattern> (clone_pattern_impl ());
   }
 
   // possible virtual methods: is_refutable()
 
   virtual ~Pattern () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
@@ -1023,24 +980,24 @@ class Type
 {
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<Type> clone_type () const
+  std::unique_ptr<Type> clone_type () const
   {
-    return ::std::unique_ptr<Type> (clone_type_impl ());
+    return std::unique_ptr<Type> (clone_type_impl ());
   }
 
   // virtual destructor
   virtual ~Type () {}
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
-  // HACK: convert to trait bound. Virtual method overriden by classes that
-  // enable this.
+  /* HACK: convert to trait bound. Virtual method overriden by classes that
+   * enable this. */
   virtual TraitBound *to_trait_bound (bool in_parens ATTRIBUTE_UNUSED) const
   {
-    return NULL;
+    return nullptr;
   }
-  // as pointer, shouldn't require definition beforehand, only forward
-  // declaration.
+  /* as pointer, shouldn't require definition beforehand, only forward
+   * declaration. */
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
@@ -1054,9 +1011,9 @@ class TypeNoBounds : public Type
 {
 public:
   // Unique pointer custom clone function
-  ::std::unique_ptr<TypeNoBounds> clone_type_no_bounds () const
+  std::unique_ptr<TypeNoBounds> clone_type_no_bounds () const
   {
-    return ::std::unique_ptr<TypeNoBounds> (clone_type_no_bounds_impl ());
+    return std::unique_ptr<TypeNoBounds> (clone_type_no_bounds_impl ());
   }
 
 protected:
@@ -1066,26 +1023,26 @@ protected:
   /* Save having to specify two clone methods in derived classes by making type
    * clone return typenobounds clone. Hopefully won't affect performance too
    * much. */
-  virtual TypeNoBounds *clone_type_impl () const OVERRIDE
+  TypeNoBounds *clone_type_impl () const override
   {
     return clone_type_no_bounds_impl ();
   }
 };
 
-// Abstract base class representing a type param bound - Lifetime and TraitBound
-// extends it
+/* Abstract base class representing a type param bound - Lifetime and TraitBound
+ * extends it */
 class TypeParamBound
 {
 public:
   virtual ~TypeParamBound () {}
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<TypeParamBound> clone_type_param_bound () const
+  std::unique_ptr<TypeParamBound> clone_type_param_bound () const
   {
-    return ::std::unique_ptr<TypeParamBound> (clone_type_param_bound_impl ());
+    return std::unique_ptr<TypeParamBound> (clone_type_param_bound_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
@@ -1110,54 +1067,54 @@ private:
 
   // TODO: LIFETIME_OR_LABEL (aka lifetime token) is only field
   // find way of enclosing token or something
-  ::std::string lifetime_name;
+  std::string lifetime_name;
   // only applies for NAMED lifetime_type
 
   Location locus;
 
 public:
   // Constructor
-  Lifetime (LifetimeType type, ::std::string name = ::std::string (),
+  Lifetime (LifetimeType type, std::string name = std::string (),
 	    Location locus = Location ())
-    : lifetime_type (type), lifetime_name (::std::move (name)), locus (locus)
+    : lifetime_type (type), lifetime_name (std::move (name)), locus (locus)
   {}
 
   // Creates an "error" lifetime.
-  static Lifetime error () { return Lifetime (NAMED, ::std::string ("")); }
+  static Lifetime error () { return Lifetime (NAMED, std::string ("")); }
 
   // Returns true if the lifetime is in an error state.
-  inline bool is_error () const
+  bool is_error () const
   {
     return lifetime_type == NAMED && lifetime_name.empty ();
   }
 
-  ::std::string as_string () const;
+  std::string as_string () const override;
 
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
+  void accept_vis (ASTVisitor &vis) override;
 
 protected:
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual Lifetime *clone_type_param_bound_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  Lifetime *clone_type_param_bound_impl () const override
   {
     return new Lifetime (*this);
   }
 };
 
-// Base generic parameter in AST. Abstract - can be represented by a Lifetime or
-// Type param
+/* Base generic parameter in AST. Abstract - can be represented by a Lifetime or
+ * Type param */
 class GenericParam
 {
 public:
   virtual ~GenericParam () {}
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<GenericParam> clone_generic_param () const
+  std::unique_ptr<GenericParam> clone_generic_param () const
   {
-    return ::std::unique_ptr<GenericParam> (clone_generic_param_impl ());
+    return std::unique_ptr<GenericParam> (clone_generic_param_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 
@@ -1173,20 +1130,20 @@ class LifetimeParam : public GenericParam
 
   // bool has_lifetime_bounds;
   // LifetimeBounds lifetime_bounds;
-  ::std::vector<Lifetime> lifetime_bounds; // inlined LifetimeBounds
+  std::vector<Lifetime> lifetime_bounds; // inlined LifetimeBounds
 
   // bool has_outer_attribute;
-  //::std::unique_ptr<Attribute> outer_attr;
+  // std::unique_ptr<Attribute> outer_attr;
   Attribute outer_attr;
 
   Location locus;
 
 public:
   // Returns whether the lifetime param has any lifetime bounds.
-  inline bool has_lifetime_bounds () const { return !lifetime_bounds.empty (); }
+  bool has_lifetime_bounds () const { return !lifetime_bounds.empty (); }
 
   // Returns whether the lifetime param has an outer attribute.
-  inline bool has_outer_attribute () const { return !outer_attr.is_empty (); }
+  bool has_outer_attribute () const { return !outer_attr.is_empty (); }
 
   // Creates an error state lifetime param.
   static LifetimeParam create_error ()
@@ -1195,16 +1152,16 @@ public:
   }
 
   // Returns whether the lifetime param is in an error state.
-  inline bool is_error () const { return lifetime.is_error (); }
+  bool is_error () const { return lifetime.is_error (); }
 
   // Constructor
   LifetimeParam (Lifetime lifetime, Location locus = Location (),
-		 ::std::vector<Lifetime> lifetime_bounds
-		 = ::std::vector<Lifetime> (),
+		 std::vector<Lifetime> lifetime_bounds
+		 = std::vector<Lifetime> (),
 		 Attribute outer_attr = Attribute::create_empty ())
-    : lifetime (::std::move (lifetime)),
-      lifetime_bounds (::std::move (lifetime_bounds)),
-      outer_attr (::std::move (outer_attr)), locus (locus)
+    : lifetime (std::move (lifetime)),
+      lifetime_bounds (std::move (lifetime_bounds)),
+      outer_attr (std::move (outer_attr)), locus (locus)
   {}
 
   // TODO: remove copy and assignment operator definitions - not required
@@ -1215,8 +1172,6 @@ public:
       outer_attr (other.outer_attr), locus (other.locus)
   {}
 
-  // Destructor - define here if required
-
   // Overloaded assignment operator to clone attribute
   LifetimeParam &operator= (LifetimeParam const &other)
   {
@@ -1232,14 +1187,14 @@ public:
   LifetimeParam (LifetimeParam &&other) = default;
   LifetimeParam &operator= (LifetimeParam &&other) = default;
 
-  ::std::string as_string () const;
+  std::string as_string () const override;
 
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
+  void accept_vis (ASTVisitor &vis) override;
 
 protected:
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual LifetimeParam *clone_generic_param_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  LifetimeParam *clone_generic_param_impl () const override
   {
     return new LifetimeParam (*this);
   }
@@ -1249,10 +1204,10 @@ protected:
 class MacroItem : public Item
 {
   /*public:
-  ::std::string as_string() const;*/
+  std::string as_string() const;*/
 protected:
-  MacroItem (::std::vector<Attribute> outer_attribs)
-    : Item (::std::move (outer_attribs))
+  MacroItem (std::vector<Attribute> outer_attribs)
+    : Item (std::move (outer_attribs))
   {}
 };
 
@@ -1261,14 +1216,14 @@ class TraitItem
 {
   // bool has_outer_attrs;
   // TODO: remove and rely on virtual functions and VisItem-derived attributes?
-  //::std::vector<Attribute> outer_attrs;
+  // std::vector<Attribute> outer_attrs;
 
   // NOTE: all children should have outer attributes
 
 protected:
   // Constructor
-  /*TraitItem(::std::vector<Attribute> outer_attrs = ::std::vector<Attribute>())
-    : outer_attrs(::std::move(outer_attrs)) {}*/
+  /*TraitItem(std::vector<Attribute> outer_attrs = std::vector<Attribute>())
+    : outer_attrs(std::move(outer_attrs)) {}*/
 
   // Clone function implementation as pure virtual method
   virtual TraitItem *clone_trait_item_impl () const = 0;
@@ -1277,23 +1232,23 @@ public:
   virtual ~TraitItem () {}
 
   // Returns whether TraitItem has outer attributes.
-  /*inline bool has_outer_attrs() const {
+  /*bool has_outer_attrs() const {
       return !outer_attrs.empty();
   }*/
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<TraitItem> clone_trait_item () const
+  std::unique_ptr<TraitItem> clone_trait_item () const
   {
-    return ::std::unique_ptr<TraitItem> (clone_trait_item_impl ());
+    return std::unique_ptr<TraitItem> (clone_trait_item_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 };
 
-// Abstract base class for items used within an inherent impl block (the impl
-// name {} one)
+/* Abstract base class for items used within an inherent impl block (the impl
+ * name {} one) */
 class InherentImplItem
 {
 protected:
@@ -1304,13 +1259,12 @@ public:
   virtual ~InherentImplItem () {}
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<InherentImplItem> clone_inherent_impl_item () const
+  std::unique_ptr<InherentImplItem> clone_inherent_impl_item () const
   {
-    return ::std::unique_ptr<InherentImplItem> (
-      clone_inherent_impl_item_impl ());
+    return std::unique_ptr<InherentImplItem> (clone_inherent_impl_item_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 };
@@ -1325,42 +1279,37 @@ public:
   virtual ~TraitImplItem (){};
 
   // Unique pointer custom clone function
-  ::std::unique_ptr<TraitImplItem> clone_trait_impl_item () const
+  std::unique_ptr<TraitImplItem> clone_trait_impl_item () const
   {
-    return ::std::unique_ptr<TraitImplItem> (clone_trait_impl_item_impl ());
+    return std::unique_ptr<TraitImplItem> (clone_trait_impl_item_impl ());
   }
 
-  virtual ::std::string as_string () const = 0;
+  virtual std::string as_string () const = 0;
 
   virtual void accept_vis (ASTVisitor &vis) = 0;
 };
 
-// A macro invocation item (or statement) AST node (i.e. semi-coloned macro
-// invocation)
+/* A macro invocation item (or statement) AST node (i.e. semi-coloned macro
+ * invocation) */
 class MacroInvocationSemi : public MacroItem,
 			    public TraitItem,
 			    public InherentImplItem,
 			    public TraitImplItem
-/*, public Statement*/ {
-  // already inherits from statement indirectly via item as item is a subclass
-  // of statement
+{
   SimplePath path;
   // all delim types except curly must have invocation end with a semicolon
   DelimType delim_type;
-  //::std::vector<TokenTree> token_trees;
-  ::std::vector< ::std::unique_ptr<TokenTree> > token_trees;
-
+  std::vector<std::unique_ptr<TokenTree>> token_trees;
   Location locus;
 
 public:
-  ::std::string as_string () const;
-
-  MacroInvocationSemi (
-    SimplePath macro_path, DelimType delim_type,
-    ::std::vector< ::std::unique_ptr<TokenTree> > token_trees,
-    ::std::vector<Attribute> outer_attribs, Location locus)
-    : MacroItem (::std::move (outer_attribs)), path (::std::move (macro_path)),
-      delim_type (delim_type), token_trees (::std::move (token_trees)),
+  std::string as_string () const override;
+
+  MacroInvocationSemi (SimplePath macro_path, DelimType delim_type,
+		       std::vector<std::unique_ptr<TokenTree>> token_trees,
+		       std::vector<Attribute> outer_attribs, Location locus)
+    : MacroItem (std::move (outer_attribs)), path (std::move (macro_path)),
+      delim_type (delim_type), token_trees (std::move (token_trees)),
       locus (locus)
   {}
   /* TODO: possible issue with Item and TraitItem hierarchies both having outer
@@ -1371,20 +1320,29 @@ public:
    * approach, but then this prevents polymorphism and would entail redoing
    * quite a bit of the parser. */
 
+  // Move constructors
+  MacroInvocationSemi (MacroInvocationSemi &&other) = default;
+  MacroInvocationSemi &operator= (MacroInvocationSemi &&other) = default;
+
+  void accept_vis (ASTVisitor &vis) override;
+
+  // Clones this macro invocation semi.
+  std::unique_ptr<MacroInvocationSemi> clone_macro_invocation_semi () const
+  {
+    return std::unique_ptr<MacroInvocationSemi> (
+      clone_macro_invocation_semi_impl ());
+  }
+
+protected:
   // Copy constructor with vector clone
   MacroInvocationSemi (MacroInvocationSemi const &other)
     : MacroItem (other), TraitItem (other), InherentImplItem (other),
       TraitImplItem (other), path (other.path), delim_type (other.delim_type),
       locus (other.locus)
   {
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     token_trees.reserve (other.token_trees.size ());
-
     for (const auto &e : other.token_trees)
-      {
-	token_trees.push_back (e->clone_token_tree ());
-      }
+      token_trees.push_back (e->clone_token_tree ());
   }
 
   // Overloaded assignment operator to vector clone
@@ -1398,58 +1356,51 @@ public:
     delim_type = other.delim_type;
     locus = other.locus;
 
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     token_trees.reserve (other.token_trees.size ());
-
     for (const auto &e : other.token_trees)
-      {
-	token_trees.push_back (e->clone_token_tree ());
-      }
+      token_trees.push_back (e->clone_token_tree ());
 
     return *this;
   }
 
-  // Move constructors
-  MacroInvocationSemi (MacroInvocationSemi &&other) = default;
-  MacroInvocationSemi &operator= (MacroInvocationSemi &&other) = default;
-
-  virtual void accept_vis (ASTVisitor &vis) OVERRIDE;
-
-protected:
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual MacroInvocationSemi *clone_item_impl () const OVERRIDE
+  MacroInvocationSemi *clone_macro_invocation_semi_impl () const
   {
     return new MacroInvocationSemi (*this);
   }
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual MacroInvocationSemi *clone_inherent_impl_item_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  MacroInvocationSemi *clone_item_impl () const override
   {
-    return new MacroInvocationSemi (*this);
+    return clone_macro_invocation_semi_impl ();
   }
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual MacroInvocationSemi *clone_trait_impl_item_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  MacroInvocationSemi *clone_inherent_impl_item_impl () const override
   {
-    return new MacroInvocationSemi (*this);
+    return clone_macro_invocation_semi_impl ();
+  }
+
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  MacroInvocationSemi *clone_trait_impl_item_impl () const override
+  {
+    return clone_macro_invocation_semi_impl ();
   }
 
   // FIXME: remove if item impl virtual override works properly
   // Use covariance to implement clone function as returning this object rather
   // than base
-  /*virtual MacroInvocationSemi* clone_statement_impl() const OVERRIDE {
-      return new MacroInvocationSemi(*this);
+  /*MacroInvocationSemi* clone_statement_impl() const override {
+      return clone_macro_invocation_semi_impl ();
   }*/
 
-  // Use covariance to implement clone function as returning this object rather
-  // than base
-  virtual MacroInvocationSemi *clone_trait_item_impl () const OVERRIDE
+  /* Use covariance to implement clone function as returning this object rather
+   * than base */
+  MacroInvocationSemi *clone_trait_item_impl () const override
   {
-    return new MacroInvocationSemi (*this);
+    return clone_macro_invocation_semi_impl ();
   }
 };
 
@@ -1459,20 +1410,19 @@ struct Crate
   bool has_utf8bom;
   bool has_shebang;
 
-  ::std::vector<Attribute> inner_attrs;
-  //::std::vector<Item> items;
+  std::vector<Attribute> inner_attrs;
   // dodgy spacing required here
-  // TODO: is it better to have a vector of items here or a module (implicit
-  // top-level one)?
-  ::std::vector< ::std::unique_ptr<Item> > items;
+  /* TODO: is it better to have a vector of items here or a module (implicit
+   * top-level one)? */
+  std::vector<std::unique_ptr<Item>> items;
 
 public:
   // Constructor
-  Crate (::std::vector< ::std::unique_ptr<Item> > items,
-	 ::std::vector<Attribute> inner_attrs, bool has_utf8bom = false,
+  Crate (std::vector<std::unique_ptr<Item>> items,
+	 std::vector<Attribute> inner_attrs, bool has_utf8bom = false,
 	 bool has_shebang = false)
     : has_utf8bom (has_utf8bom), has_shebang (has_shebang),
-      inner_attrs (::std::move (inner_attrs)), items (::std::move (items))
+      inner_attrs (std::move (inner_attrs)), items (std::move (items))
   {}
 
   // Copy constructor with vector clone
@@ -1480,14 +1430,9 @@ public:
     : has_utf8bom (other.has_utf8bom), has_shebang (other.has_shebang),
       inner_attrs (other.inner_attrs)
   {
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     items.reserve (other.items.size ());
-
     for (const auto &e : other.items)
-      {
-	items.push_back (e->clone_item ());
-      }
+      items.push_back (e->clone_item ());
   }
 
   ~Crate () = default;
@@ -1499,14 +1444,9 @@ public:
     has_shebang = other.has_shebang;
     has_utf8bom = other.has_utf8bom;
 
-    // crappy vector unique pointer clone - TODO is there a better way of doing
-    // this?
     items.reserve (other.items.size ());
-
     for (const auto &e : other.items)
-      {
-	items.push_back (e->clone_item ());
-      }
+      items.push_back (e->clone_item ());
 
     return *this;
   }
@@ -1516,25 +1456,25 @@ public:
   Crate &operator= (Crate &&other) = default;
 
   // Get crate representation as string (e.g. for debugging).
-  ::std::string as_string () const;
+  std::string as_string () const;
 };
 
 // Base path expression AST node - abstract
 class PathExpr : public ExprWithoutBlock
 {
 protected:
-  PathExpr (::std::vector<Attribute> outer_attribs)
-    : ExprWithoutBlock (::std::move (outer_attribs))
+  PathExpr (std::vector<Attribute> outer_attribs)
+    : ExprWithoutBlock (std::move (outer_attribs))
   {}
 
 public:
   // TODO: think of a better and less hacky way to allow this
 
-  // Replaces the outer attributes of this path expression with the given outer
-  // attributes.
-  void replace_outer_attrs (::std::vector<Attribute> outer_attrs)
+  /* Replaces the outer attributes of this path expression with the given outer
+   * attributes. */
+  void replace_outer_attrs (std::vector<Attribute> outer_attrs)
   {
-    set_outer_attrs (::std::move (outer_attrs));
+    set_outer_attrs (std::move (outer_attrs));
   }
 };
 } // namespace AST