#include "rust-ast-builder.h"
#include "rust-ast-full.h"
#include "rust-common.h"
-#include "rust-make-unique.h"
namespace Rust {
namespace AST {
#include "rust-expr.h"
#include "rust-path.h"
#include "rust-token.h"
-#include "rust-make-unique.h"
namespace Rust {
namespace AST {
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));
}
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 ());
#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 {
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 ()));
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));
}
: 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)
{}
: outer_attrs (std::move (outer_attrs)),
has_opening_scope_resolution (false), locus (locus),
_node_id (Analysis::Mappings::get ().get_next_node_id ()),
- path (Rust::make_unique<LangItemPath> (lang_item_kind, locus)),
+ path (std::make_unique<LangItemPath> (lang_item_kind, locus)),
marked_for_strip (false)
{}
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 ()))
{}
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> ()));
// `$crate::core::marker::Copy` instead
auto segments = std::vector<std::unique_ptr<TypePathSegment>> ();
segments.emplace_back (builder.type_path_segment ("Copy"));
- auto copy = Rust::make_unique<LangItemPath> (LangItem::Kind::COPY, loc);
+ auto copy = std::make_unique<LangItemPath> (LangItem::Kind::COPY, loc);
// we need to build up the generics for this impl block which will be just a
// clone of the types specified ones
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));
// <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"
// 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)));
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)));
}
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),
+ 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 ());
StructExprStruct::operator= (other);
struct_base = other.has_struct_base ()
? tl::optional<std::unique_ptr<StructBase>> (
- Rust::make_unique<StructBase> (*other.struct_base.value ()))
+ std::make_unique<StructBase> (*other.struct_base.value ()))
: tl::nullopt;
union_index = other.union_index;
// 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
#include "rust-system.h"
#include "rust-linemap.h"
-#include "rust-make-unique.h"
#include "rust-unicode.h"
namespace Rust {
: 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));
}
: 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 ()));
}
: 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));
}
#include "rust-system.h"
#include "rust-diagnostics.h"
#include "rust-imports.h"
-#include "rust-make-unique.h"
#ifndef O_BINARY
#define O_BINARY 0
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;
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)
#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
//
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))
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.
#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"
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));
}
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));
}
{
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));
}
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);
}
}
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
{
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 (), {}));
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 (), {}));
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 (), {}));
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)));
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)));
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));
}
#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
// 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)));
std::vector<std::unique_ptr<HIR::Type>> inputs;
inputs.push_back (
- Rust::make_unique<HIR::TupleType> (mapping, std::move (params_copy),
- final_seg.get_locus ()));
+ std::make_unique<HIR::TupleType> (mapping, std::move (params_copy),
+ final_seg.get_locus ()));
// resolve the fn_once_output type which assumes there must be an output
// set
+++ /dev/null
-// Copyright (C) 2020-2025 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 3, or (at your option) any later
-// version.
-
-// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-// for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with GCC; see the file COPYING3. If not see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef RUST_MAKE_UNIQUE_H
-#define RUST_MAKE_UNIQUE_H
-
-#include "rust-system.h"
-
-namespace Rust {
-
-template <typename T, typename... Ts>
-std::unique_ptr<T>
-make_unique (Ts &&...params)
-{
- return std::unique_ptr<T> (new T (std::forward<Ts> (params)...));
-}
-
-} // namespace Rust
-
-#endif // RUST_MAKE_UNIQUE_H
projects / thirdparty / gcc.git / commitdiff
