Remove Rust::make_unique

Since our bootstrap requirement has been bumped to C++14, we don't need
a custom implementation of std::make_unique anymore.

gcc/rust/ChangeLog:

	* ast/rust-ast-builder-type.cc: Remove inclusion of
	rust-make-unique.h.
	* ast/rust-ast-builder.cc: Likewise.
	(Builder::array): Use std::make_unique instead of
	Rust::make_unique.
	* ast/rust-ast.cc (Attribute::get_traits_to_derive): Likewise.
	* ast/rust-macro.h: Remove inclusion of rust-make-unique.h.
	(MacroRulesDefinition::mbe): Use std::make_unique instead of
	Rust::make_unique.
	(MacroRulesDefinition::decl_macro): Likewise.
	* ast/rust-path.h
	(PathInExpression::PathInExpression): Likewise.
	(QualifiedPathInExpression::QualifiedPathInExpression):
	Likewise.
	* backend/rust-compile-pattern.cc
	(CompilePatternCheckExpr::visit): Likewise.
	* expand/rust-expand-format-args.cc
	(expand_format_args): Likewise.
	* expand/rust-macro-builtins-asm.cc: Remove inclusion of
	rust-make-unique.h.
	(parse_asm): Use std::make_unique instead of Rust::make_unique.
	* hir/rust-ast-lower-expr.cc
	(ASTLoweringExpr::visit): Likewise.
	* hir/tree/rust-hir-expr.cc
	(StructExprStructFields::StructExprStructFields): Likewise.
	(StructExprStructFields::operator=): Likewise.
	* hir/tree/rust-hir.cc
	(TypePath::to_trait_bound): Likewise.
	* lex/rust-token.h: Remove inclusion of rust-make-unique.h.
	(Token::Token): Use std::make_unique instead of
	Rust::make_unique.
	* metadata/rust-import-archive.cc: Remove inclusion of
	rust-make-unique.h.
	(Import::find_archive_export_data): Use std::make_unique instead
	of Rust::make_unique.
	* metadata/rust-imports.cc: Remove inclusion of
	rust-make-unique.h.
	(Import::find_export_data): Use std::make_unique instead of
	Rust::make_unique.
	(Import::find_object_export_data): Likewise.
	* parse/rust-parse-impl.h: Remove inclusion of
	rust-make-unique.h.
	(Parser::parse_function_param): Use std::make_unique instead of
	Rust::make_unique.
	(Parser::parse_self_param): Likewise.
	(Parser::parse_array_expr): Likewise.
	* typecheck/rust-hir-type-check-enumitem.cc
	(TypeCheckEnumItem::visit): Likewise.
	* typecheck/rust-hir-type-check-implitem.cc
	(TypeCheckTopLevelExternItem::visit): Likewise.
	(TypeCheckImplItem::visit): Likewise.
	* typecheck/rust-hir-type-check-type.cc
	(TypeResolveGenericParam::visit): Likewise.
	* typecheck/rust-hir-type-check.cc: Remove inclusion of
	rust-make-unique.h.
	(TraitItemReference::get_type_from_fn): Use std::make_unique
	instead of Rust::make_unique.
	* typecheck/rust-tyty-bounds.cc
	(TypeCheckBase::get_predicate_from_bound): Likewise.
	* util/rust-make-unique.h: Removed.

Signed-off-by: Owen Avery <[email protected]>

gcc/rust/ast/rust-ast-builder-type.cc

@@ -20,7 +20,6 @@
 #include "rust-ast-builder.h"
 #include "rust-ast-full.h"
 #include "rust-common.h"
-#include "rust-make-unique.h"
 
 namespace Rust {
 namespace AST {

gcc/rust/ast/rust-ast-builder.cc

@@ -21,7 +21,6 @@
 #include "rust-common.h"
 #include "rust-expr.h"
 #include "rust-token.h"
-#include "rust-make-unique.h"
 
 namespace Rust {
 namespace AST {
@@ -45,7 +44,7 @@ Builder::call (std::unique_ptr<Expr> &&path,
 std::unique_ptr<Expr>
 Builder::array (std::vector<std::unique_ptr<Expr>> &&members) const
 {
-  auto elts = Rust::make_unique<ArrayElemsValues> (std::move (members), loc);
+  auto elts = std::make_unique<ArrayElemsValues> (std::move (members), loc);
 
   return std::unique_ptr<Expr> (new ArrayExpr (std::move (elts), {}, {}, loc));
 }

gcc/rust/ast/rust-ast.cc

@@ -272,8 +272,8 @@ Attribute::get_traits_to_derive ()
 		      case AST::MetaItem::ItemKind::Word: {
 			auto word = static_cast<AST::MetaWord *> (meta_item);
 			// Convert current word to path
-			current
-			  = make_unique<AST::MetaItemPath> (AST::MetaItemPath (
+			current = std::make_unique<AST::MetaItemPath> (
+			  AST::MetaItemPath (
 			    AST::SimplePath (word->get_ident ())));
 			auto path
 			  = static_cast<AST::MetaItemPath *> (current.get ());

gcc/rust/ast/rust-macro.h

@@ -24,7 +24,6 @@
 #include "rust-ast-fragment.h"
 #include "rust-location.h"
 #include "rust-item.h"
-#include "rust-make-unique.h"
 #include "rust-macro-builtins.h"
 
 namespace Rust {
@@ -521,7 +520,7 @@ class MacroRulesDefinition : public VisItem
   mbe (Identifier rule_name, DelimType delim_type, std::vector<MacroRule> rules,
        std::vector<Attribute> outer_attrs, location_t locus)
   {
-    return Rust::make_unique<MacroRulesDefinition> (
+    return std::make_unique<MacroRulesDefinition> (
       MacroRulesDefinition (rule_name, delim_type, rules, outer_attrs, locus,
 			    AST::MacroRulesDefinition::MacroKind::MBE,
 			    AST::Visibility::create_error ()));
@@ -532,7 +531,7 @@ class MacroRulesDefinition : public VisItem
 	      std::vector<Attribute> outer_attrs, location_t locus,
 	      Visibility vis)
   {
-    return Rust::make_unique<MacroRulesDefinition> (MacroRulesDefinition (
+    return std::make_unique<MacroRulesDefinition> (MacroRulesDefinition (
       rule_name, AST::DelimType::CURLY, rules, outer_attrs, locus,
       AST::MacroRulesDefinition::MacroKind::DeclMacro, vis));
   }

gcc/rust/ast/rust-path.h

@@ -701,8 +701,8 @@ class PathInExpression : public Pattern, public ExprWithoutBlock
     : outer_attrs (std::move (outer_attrs)),
       has_opening_scope_resolution (has_opening_scope_resolution),
       locus (locus), _node_id (Analysis::Mappings::get ().get_next_node_id ()),
-      path (Rust::make_unique<RegularPath> (std::move (path_segments), locus,
-					    _node_id)),
+      path (std::make_unique<RegularPath> (std::move (path_segments), locus,
+					   _node_id)),
       marked_for_strip (false)
   {}
 
@@ -1401,7 +1401,7 @@ class QualifiedPathInExpression : public Pattern, public ExprWithoutBlock
 			     location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       path_type (std::move (qual_path_type)),
-      path (Rust::make_unique<RegularPath> (
+      path (std::make_unique<RegularPath> (
 	std::move (path_segments), locus,
 	Analysis::Mappings::get ().get_next_node_id ()))
   {}

gcc/rust/backend/rust-compile-pattern.cc

@@ -80,7 +80,7 @@ void
 CompilePatternCheckExpr::visit (HIR::LiteralPattern &pattern)
 {
   // Compile the literal
-  auto litexpr = Rust::make_unique<HIR::LiteralExpr> (
+  auto litexpr = std::make_unique<HIR::LiteralExpr> (
     HIR::LiteralExpr (pattern.get_mappings (), pattern.get_literal (),
 		      pattern.get_locus (), std::vector<AST::Attribute> ()));
 

gcc/rust/expand/rust-expand-format-args.cc

@@ -120,7 +120,7 @@ expand_format_args (AST::FormatArgs &fmt,
   auto pieces = builder.ref (builder.array (std::move (static_pieces)));
   auto args_slice = builder.ref (builder.array (std::move (args_array)));
 
-  auto final_path = make_unique<AST::PathInExpression> (
+  auto final_path = std::make_unique<AST::PathInExpression> (
     builder.path_in_expression ({"core", "fmt", "Arguments", "new_v1"}));
   auto final_args = std::vector<std::unique_ptr<AST::Expr>> ();
   final_args.emplace_back (std::move (pieces));

gcc/rust/expand/rust-macro-builtins-asm.cc

@@ -17,7 +17,6 @@
 // <http://www.gnu.org/licenses/>.
 
 #include "expected.h"
-#include "rust-make-unique.h"
 #include "rust-macro-builtins-asm.h"
 #include "rust-ast-fragment.h"
 #include "rust-ast.h"
@@ -858,9 +857,9 @@ parse_asm (location_t invoc_locus, AST::MacroInvocData &invoc,
       // properly.
       if (semicolon == AST::InvocKind::Semicoloned)
 	single_vec.emplace_back (AST::SingleASTNode (
-	  Rust::make_unique<AST::ExprStmt> (std::move (node), invoc_locus,
-					    semicolon
-					      == AST::InvocKind::Semicoloned)));
+	  std::make_unique<AST::ExprStmt> (std::move (node), invoc_locus,
+					   semicolon
+					     == AST::InvocKind::Semicoloned)));
       else
 	single_vec.emplace_back (AST::SingleASTNode (std::move (node)));
 

gcc/rust/hir/rust-ast-lower-expr.cc

@@ -518,7 +518,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
       HIR::Expr *translated_base = ASTLoweringExpr::translate (
 	struct_expr.get_struct_base ().get_base_struct ());
       base = tl::optional<std::unique_ptr<HIR::StructBase>> (
-	Rust::make_unique<StructBase> (
+	std::make_unique<StructBase> (
 	  std::unique_ptr<HIR::Expr> (translated_base)));
     }
 

gcc/rust/hir/tree/rust-hir-expr.cc

@@ -542,9 +542,10 @@ StructExprStructFields::StructExprStructFields (
   StructExprStructFields const &other)
   : StructExprStruct (other),
     struct_base (
-      other.has_struct_base () ? tl::optional<std::unique_ptr<StructBase>> (
-	Rust::make_unique<StructBase> (*other.struct_base.value ()))
-			       : tl::nullopt),
+      other.has_struct_base ()
+	? tl::optional<std::unique_ptr<StructBase>> (
+	    std::make_unique<StructBase> (*other.struct_base.value ()))
+	: tl::nullopt),
     union_index (other.union_index)
 {
   fields.reserve (other.fields.size ());
@@ -556,10 +557,11 @@ StructExprStructFields &
 StructExprStructFields::operator= (StructExprStructFields const &other)
 {
   StructExprStruct::operator= (other);
-  struct_base = other.has_struct_base ()
-		  ? tl::optional<std::unique_ptr<StructBase>> (
-		    Rust::make_unique<StructBase> (*other.struct_base.value ()))
-		  : tl::nullopt;
+  struct_base
+    = other.has_struct_base ()
+	? tl::optional<std::unique_ptr<StructBase>> (
+	    std::make_unique<StructBase> (*other.struct_base.value ()))
+	: tl::nullopt;
   union_index = other.union_index;
 
   fields.reserve (other.fields.size ());

gcc/rust/hir/tree/rust-hir.cc

@@ -2710,8 +2710,8 @@ TypePath::to_trait_bound (bool in_parens) const
   // create clone FIXME is this required? or is copy constructor automatically
   // called?
   TypePath copy (*this);
-  return Rust::make_unique<TraitBound> (mappings, std::move (copy),
-					copy.get_locus (), in_parens);
+  return std::make_unique<TraitBound> (mappings, std::move (copy),
+				       copy.get_locus (), in_parens);
 }
 
 std::string

gcc/rust/lex/rust-token.h

@@ -21,7 +21,6 @@
 
 #include "rust-system.h"
 #include "rust-linemap.h"
-#include "rust-make-unique.h"
 #include "rust-unicode.h"
 
 namespace Rust {
@@ -268,7 +267,7 @@ class Token
     : token_id (token_id), locus (location), type_hint (CORETYPE_UNKNOWN)
   {
     // Normalize identifier tokens
-    str = Rust::make_unique<std::string> (
+    str = std::make_unique<std::string> (
       nfc_normalize_token_string (location, token_id, paramStr));
   }
 
@@ -285,7 +284,7 @@ class Token
     : token_id (token_id), locus (location), type_hint (CORETYPE_UNKNOWN)
   {
     // Normalize identifier tokens
-    str = Rust::make_unique<std::string> (
+    str = std::make_unique<std::string> (
       nfc_normalize_token_string (location, token_id,
 				  paramCodepoint.as_string ()));
   }
@@ -296,7 +295,7 @@ class Token
     : token_id (token_id), locus (location), type_hint (parType)
   {
     // Normalize identifier tokens
-    str = Rust::make_unique<std::string> (
+    str = std::make_unique<std::string> (
       nfc_normalize_token_string (location, token_id, paramStr));
   }
 

gcc/rust/metadata/rust-import-archive.cc

@@ -7,7 +7,6 @@
 #include "rust-system.h"
 #include "rust-diagnostics.h"
 #include "rust-imports.h"
-#include "rust-make-unique.h"
 
 #ifndef O_BINARY
 #define O_BINARY 0
@@ -844,7 +843,7 @@ Import::find_archive_export_data (const std::string &filename, int fd,
   if (!afile.initialize ())
     return nullptr;
 
-  auto ret = Rust::make_unique<Stream_concatenate> ();
+  auto ret = std::make_unique<Stream_concatenate> ();
 
   bool any_data = false;
   bool any_members = false;
@@ -872,7 +871,7 @@ Import::find_archive_export_data (const std::string &filename, int fd,
   if (!any_members)
     {
       // It's normal to have an empty archive file when using gobuild.
-      return Rust::make_unique<Stream_from_string> ("");
+      return std::make_unique<Stream_from_string> ("");
     }
 
   if (!any_data)

gcc/rust/metadata/rust-imports.cc

@@ -21,7 +21,6 @@
 #include "rust-imports.h"
 #include "rust-object-export.h"
 #include "rust-export-metadata.h"
-#include "rust-make-unique.h"
 
 #ifndef O_BINARY
 #define O_BINARY 0
@@ -259,7 +258,7 @@ Import::find_export_data (const std::string &filename, int fd,
   //
   if (memcmp (buf, Metadata::kMagicHeader, sizeof (Metadata::kMagicHeader))
       == 0)
-    return Rust::make_unique<Stream_from_file> (fd);
+    return std::make_unique<Stream_from_file> (fd);
 
   // See if we can read this as an archive.
   if (Import::is_archive_magic (buf))
@@ -291,7 +290,7 @@ Import::find_object_export_data (const std::string &filename, int fd,
   if (buf == nullptr)
     return nullptr;
 
-  return Rust::make_unique<Stream_from_buffer> (buf, len);
+  return std::make_unique<Stream_from_buffer> (buf, len);
 }
 
 // Class Import.

gcc/rust/parse/rust-parse-impl.h

@@ -29,7 +29,6 @@
 #include "rust-token.h"
 #define INCLUDE_ALGORITHM
 #include "rust-diagnostics.h"
-#include "rust-make-unique.h"
 #include "rust-dir-owner.h"
 #include "rust-attribute-values.h"
 #include "rust-keyword-values.h"
@@ -3683,7 +3682,7 @@ Parser<ManagedTokenSource>::parse_function_param ()
   if (lexer.peek_token ()->get_id () == ELLIPSIS) // Unnamed variadic
     {
       lexer.skip_token (); // Skip ellipsis
-      return Rust::make_unique<AST::VariadicParam> (
+      return std::make_unique<AST::VariadicParam> (
 	AST::VariadicParam (std::move (outer_attrs), locus));
     }
 
@@ -3705,7 +3704,7 @@ Parser<ManagedTokenSource>::parse_function_param ()
   if (lexer.peek_token ()->get_id () == ELLIPSIS) // Named variadic
     {
       lexer.skip_token (); // Skip ellipsis
-      return Rust::make_unique<AST::VariadicParam> (
+      return std::make_unique<AST::VariadicParam> (
 	AST::VariadicParam (std::move (param_pattern), std::move (outer_attrs),
 			    locus));
     }
@@ -3716,7 +3715,7 @@ Parser<ManagedTokenSource>::parse_function_param ()
 	{
 	  return nullptr;
 	}
-      return Rust::make_unique<AST::FunctionParam> (
+      return std::make_unique<AST::FunctionParam> (
 	AST::FunctionParam (std::move (param_pattern), std::move (param_type),
 			    std::move (outer_attrs), locus));
     }
@@ -7124,14 +7123,14 @@ Parser<ManagedTokenSource>::parse_self_param ()
 
   if (has_reference)
     {
-      return Rust::make_unique<AST::SelfParam> (std::move (lifetime), has_mut,
-						locus);
+      return std::make_unique<AST::SelfParam> (std::move (lifetime), has_mut,
+					       locus);
     }
   else
     {
       // note that type may be nullptr here and that's fine
-      return Rust::make_unique<AST::SelfParam> (std::move (type), has_mut,
-						locus);
+      return std::make_unique<AST::SelfParam> (std::move (type), has_mut,
+					       locus);
     }
 }
 
@@ -8693,10 +8692,10 @@ Parser<ManagedTokenSource>::parse_array_expr (AST::AttrVec outer_attrs,
 
       std::vector<std::unique_ptr<AST::Expr>> exprs;
       auto array_elems
-	= Rust::make_unique<AST::ArrayElemsValues> (std::move (exprs), locus);
-      return Rust::make_unique<AST::ArrayExpr> (std::move (array_elems),
-						std::move (inner_attrs),
-						std::move (outer_attrs), locus);
+	= std::make_unique<AST::ArrayElemsValues> (std::move (exprs), locus);
+      return std::make_unique<AST::ArrayExpr> (std::move (array_elems),
+					       std::move (inner_attrs),
+					       std::move (outer_attrs), locus);
     }
   else
     {

gcc/rust/typecheck/rust-hir-type-check-enumitem.cc

@@ -69,7 +69,7 @@ TypeCheckEnumItem::visit (HIR::EnumItem &item)
 				 mappings.get_next_hir_id (
 				   item.get_mappings ().get_crate_num ()),
 				 item.get_mappings ().get_local_defid ());
-  auto discim_expr = Rust::make_unique<HIR::LiteralExpr> (
+  auto discim_expr = std::make_unique<HIR::LiteralExpr> (
     HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
 		      HIR::Literal::LitType::INT,
 		      PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));
@@ -174,7 +174,7 @@ TypeCheckEnumItem::visit (HIR::EnumItemTuple &item)
 				 mappings.get_next_hir_id (
 				   item.get_mappings ().get_crate_num ()),
 				 item.get_mappings ().get_local_defid ());
-  auto discim_expr = Rust::make_unique<HIR::LiteralExpr> (
+  auto discim_expr = std::make_unique<HIR::LiteralExpr> (
     HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
 		      HIR::Literal::LitType::INT,
 		      PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));
@@ -234,7 +234,7 @@ TypeCheckEnumItem::visit (HIR::EnumItemStruct &item)
 				 mappings.get_next_hir_id (
 				   item.get_mappings ().get_crate_num ()),
 				 item.get_mappings ().get_local_defid ());
-  auto discrim_expr = Rust::make_unique<HIR::LiteralExpr> (
+  auto discrim_expr = std::make_unique<HIR::LiteralExpr> (
     HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
 		      HIR::Literal::LitType::INT,
 		      PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));

gcc/rust/typecheck/rust-hir-type-check-implitem.cc

@@ -142,7 +142,7 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function)
 				     mappings.get_next_hir_id (crate_num),
 				     UNKNOWN_LOCAL_DEFID);
 
-      auto param_pattern = Rust::make_unique<HIR::IdentifierPattern> (
+      auto param_pattern = std::make_unique<HIR::IdentifierPattern> (
 	HIR::IdentifierPattern (mapping, param.get_param_name (),
 				UNDEF_LOCATION, false, Mutability::Imm,
 				std::unique_ptr<HIR::Pattern> (nullptr)));
@@ -390,7 +390,7 @@ TypeCheckImplItem::visit (HIR::Function &function)
       HIR::SelfParam &self_param = function.get_self_param ();
       // FIXME: which location should be used for Rust::Identifier for `self`?
       std::unique_ptr<HIR::Pattern> self_pattern
-	= Rust::make_unique<HIR::IdentifierPattern> (
+	= std::make_unique<HIR::IdentifierPattern> (
 	  HIR::IdentifierPattern (mapping, {"self"}, self_param.get_locus (),
 				  self_param.is_ref (), self_param.get_mut (),
 				  std::unique_ptr<HIR::Pattern> (nullptr)));

gcc/rust/typecheck/rust-hir-type-check-type.cc

@@ -919,7 +919,7 @@ TypeResolveGenericParam::visit (HIR::TypeParam &param)
 				      param.get_mappings ().get_nodeid (),
 				      implicit_id,
 				      param.get_mappings ().get_local_defid ());
-      implicit_self_bound = Rust::make_unique<HIR::TypePath> (
+      implicit_self_bound = std::make_unique<HIR::TypePath> (
 	HIR::TypePath (mappings, {}, BUILTINS_LOCATION, false));
     }
 

gcc/rust/typecheck/rust-hir-type-check.cc

@@ -24,7 +24,6 @@
 #include "rust-hir-type-check-item.h"
 #include "rust-hir-type-check-pattern.h"
 #include "rust-hir-type-check-struct-field.h"
-#include "rust-make-unique.h"
 #include "rust-immutable-name-resolution-context.h"
 
 // for flag_name_resolution_2_0
@@ -238,7 +237,7 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
       // but we reuse the HIR identifier pattern which requires it
       HIR::SelfParam &self_param = function.get_self ();
       std::unique_ptr<HIR::Pattern> self_pattern
-	= Rust::make_unique<HIR::IdentifierPattern> (HIR::IdentifierPattern (
+	= std::make_unique<HIR::IdentifierPattern> (HIR::IdentifierPattern (
 	  mapping, {"self"}, self_param.get_locus (), self_param.is_ref (),
 	  self_param.is_mut () ? Mutability::Mut : Mutability::Imm,
 	  std::unique_ptr<HIR::Pattern> (nullptr)));