summaryrefslogtreecommitdiff
path: root/src/expand
diff options
context:
space:
mode:
Diffstat (limited to 'src/expand')
-rw-r--r--src/expand/asm.cpp4
-rw-r--r--src/expand/assert.cpp8
-rw-r--r--src/expand/cfg.cpp12
-rw-r--r--src/expand/concat.cpp4
-rw-r--r--src/expand/derive.cpp276
-rw-r--r--src/expand/env.cpp20
-rw-r--r--src/expand/file_line.cpp14
-rw-r--r--src/expand/format_args.cpp63
-rw-r--r--src/expand/include.cpp15
-rw-r--r--src/expand/macro_rules.cpp15
-rw-r--r--src/expand/mod.cpp19
-rw-r--r--src/expand/proc_macro.cpp16
-rw-r--r--src/expand/proc_macro.hpp8
-rw-r--r--src/expand/rustc_diagnostics.cpp14
-rw-r--r--src/expand/stringify.cpp2
-rw-r--r--src/expand/test.cpp2
-rw-r--r--src/expand/test_harness.cpp4
17 files changed, 241 insertions, 255 deletions
diff --git a/src/expand/asm.cpp b/src/expand/asm.cpp
index d895c32d..f8b3984d 100644
--- a/src/expand/asm.cpp
+++ b/src/expand/asm.cpp
@@ -35,12 +35,10 @@ namespace
class CAsmExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
auto lex = TTStream(sp, tt);
- if( ident != "" )
- ERROR(sp, E0000, "asm! doesn't take an ident");
auto template_text = get_string(sp, lex, crate, mod);
::std::vector<::AST::ExprNode_Asm::ValRef> outputs;
diff --git a/src/expand/assert.cpp b/src/expand/assert.cpp
index 5bb23bde..ffba7b98 100644
--- a/src/expand/assert.cpp
+++ b/src/expand/assert.cpp
@@ -15,14 +15,12 @@
class CExpander_assert:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
auto lex = TTStream(sp, tt);
lex.parse_state().module = &mod;
- if( ident != "" )
- ERROR(sp, E0000, "format_args! doesn't take an ident");
// assertion condition
auto n = Parse_Expr0(lex);
@@ -39,7 +37,7 @@ class CExpander_assert:
toks.push_back( Token(InterpolatedFragment(InterpolatedFragment::EXPR, n.release())) );
toks.push_back( Token(TOK_BRACE_OPEN) );
// User-provided message
- toks.push_back( Token(TOK_IDENT, "panic") );
+ toks.push_back( Token(TOK_IDENT, RcString::new_interned("panic")) );
toks.push_back( Token(TOK_EXCLAM) );
toks.push_back( Token(TOK_PAREN_OPEN) );
while(lex.lookahead(0) != TOK_EOF )
@@ -63,7 +61,7 @@ class CExpander_assert:
toks.push_back( Token(TOK_BRACE_OPEN) );
// Auto-generated message
- toks.push_back( Token(TOK_IDENT, "panic") );
+ toks.push_back( Token(TOK_IDENT, RcString::new_interned("panic")) );
toks.push_back( Token(TOK_EXCLAM) );
toks.push_back( Token(TOK_PAREN_OPEN) );
toks.push_back( Token(TOK_STRING, ss.str()) );
diff --git a/src/expand/cfg.cpp b/src/expand/cfg.cpp
index 773a38c4..7e922779 100644
--- a/src/expand/cfg.cpp
+++ b/src/expand/cfg.cpp
@@ -60,7 +60,7 @@ bool check_cfg(const Span& sp, const ::AST::Attribute& mi) {
}
else if( mi.has_string() ) {
// Equaliy
- auto its = g_cfg_values.equal_range(mi.name());
+ auto its = g_cfg_values.equal_range(mi.name().c_str());
for(auto it = its.first; it != its.second; ++it)
{
DEBUG(""<<mi.name()<<": '"<<it->second<<"' == '"<<mi.string()<<"'");
@@ -70,7 +70,7 @@ bool check_cfg(const Span& sp, const ::AST::Attribute& mi) {
if( its.first != its.second )
return false;
- auto it2 = g_cfg_value_fcns.find(mi.name());
+ auto it2 = g_cfg_value_fcns.find(mi.name().c_str());
if(it2 != g_cfg_value_fcns.end() )
{
DEBUG(""<<mi.name()<<": ('"<<mi.string()<<"')?");
@@ -82,7 +82,7 @@ bool check_cfg(const Span& sp, const ::AST::Attribute& mi) {
}
else {
// Flag
- auto it = g_cfg_flags.find(mi.name());
+ auto it = g_cfg_flags.find(mi.name().c_str());
return (it != g_cfg_flags.end());
}
BUG(sp, "Fell off the end of check_cfg");
@@ -91,12 +91,8 @@ bool check_cfg(const Span& sp, const ::AST::Attribute& mi) {
class CCfgExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" ) {
- ERROR(sp, E0000, "cfg! doesn't take an identifier");
- }
-
auto lex = TTStream(sp, tt);
auto attrs = Parse_MetaItem(lex);
DEBUG("cfg!() - " << attrs);
diff --git a/src/expand/concat.cpp b/src/expand/concat.cpp
index 29a066df..bd741e2f 100644
--- a/src/expand/concat.cpp
+++ b/src/expand/concat.cpp
@@ -16,13 +16,11 @@
class CConcatExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
auto lex = TTStream(sp, tt);
- if( ident != "" )
- ERROR(sp, E0000, "format_args! doesn't take an ident");
::std::string rv;
do {
diff --git a/src/expand/derive.cpp b/src/expand/derive.cpp
index dddd82b6..6dea3028 100644
--- a/src/expand/derive.cpp
+++ b/src/expand/derive.cpp
@@ -58,6 +58,15 @@ static inline ::std::vector<T> vec$(T v1, T v2, T v3, T v4, T v5) {
tmp.push_back( mv$(v5) );
return mv$(tmp);
}
+static AST::Path get_path(const RcString& core_name, ::std::string c1, ::std::string c2)
+{
+ return AST::Path(core_name, { AST::PathNode(RcString::new_interned(c1), {}), AST::PathNode(RcString::new_interned(c2), {}) });
+}
+static AST::Path get_path(const RcString& core_name, ::std::string c1, ::std::string c2, ::std::string c3)
+{
+ return AST::Path(core_name, { AST::PathNode(RcString::new_interned(c1), {}), AST::PathNode(RcString::new_interned(c2), {}), AST::PathNode(RcString::new_interned(c3), {}) });
+}
+
static inline AST::ExprNodeP mk_exprnodep(AST::ExprNode* en){ return AST::ExprNodeP(en); }
//#define NEWNODE(type, ...) mk_exprnodep(new type(__VA_ARGS__))
@@ -65,7 +74,7 @@ static inline AST::ExprNodeP mk_exprnodep(AST::ExprNode* en){ return AST::ExprNo
struct DeriveOpts
{
- ::std::string core_name;
+ RcString core_name;
const ::std::vector<::AST::Attribute>& derive_items;
};
@@ -288,7 +297,7 @@ class Deriver_Debug:
// throw CompileError::Todo("derive(Debug) - _try");
//}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path debug_trait = AST::Path(core_name, { AST::PathNode("fmt", {}), AST::PathNode("Debug", {}) });
TypeRef f_type(TypeRef::TagReference(), sp, AST::LifetimeRef(), true,
@@ -319,7 +328,7 @@ public:
AST::Impl handle_item(Span sp, const DeriveOpts& opts, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
- const ::std::string& name = type.path().nodes().back().name();
+ ::std::string name = type.path().nodes().back().name().c_str();
// Generate code for Debug
AST::ExprNodeP node;
@@ -342,7 +351,7 @@ public:
node = NEWNODE(CallMethod,
mv$(node), AST::PathNode("field",{}),
vec$(
- NEWNODE(String, fld.m_name),
+ NEWNODE(String, fld.m_name.c_str()),
NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(UniOp, AST::ExprNode_UniOp::REF,
NEWNODE(Field,
NEWNODE(NamedValue, AST::Path("self")),
@@ -368,7 +377,7 @@ public:
NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(UniOp, AST::ExprNode_UniOp::REF,
NEWNODE(Field,
NEWNODE(NamedValue, AST::Path("self")),
- FMT(idx)
+ RcString::new_interned(FMT(idx))
)
))
)
@@ -396,7 +405,7 @@ public:
code = NEWNODE(CallMethod,
NEWNODE(NamedValue, AST::Path("f")),
AST::PathNode("write_str",{}),
- vec$( NEWNODE(String, v.m_name) )
+ vec$( NEWNODE(String, v.m_name.c_str()) )
);
pat_a = AST::Pattern(AST::Pattern::TagValue(), sp, AST::Pattern::Value::make_Named(base_path + v.m_name));
),
@@ -407,12 +416,12 @@ public:
node = NEWNODE(NamedValue, AST::Path("f"));
node = NEWNODE(CallMethod,
mv$(node), AST::PathNode("debug_tuple",{}),
- vec$( NEWNODE(String, v.m_name) )
+ vec$( NEWNODE(String, v.m_name.c_str()) )
);
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
node = NEWNODE(CallMethod,
@@ -427,24 +436,24 @@ public:
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), sp, base_path + v.m_name, mv$(pats_a));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
AST::ExprNodeP node;
node = NEWNODE(NamedValue, AST::Path("f"));
node = NEWNODE(CallMethod,
mv$(node), AST::PathNode("debug_struct",{}),
- vec$( NEWNODE(String, v.m_name) )
+ vec$( NEWNODE(String, v.m_name.c_str()) )
);
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
node = NEWNODE(CallMethod,
mv$(node), AST::PathNode("field",{}),
vec$(
- NEWNODE(String, fld.m_name),
+ NEWNODE(String, fld.m_name.c_str()),
NEWNODE(NamedValue, AST::Path(name_a))
)
);
@@ -476,7 +485,7 @@ public:
class Deriver_PartialEq:
public Deriver
{
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path(core_name, { AST::PathNode("cmp", {}), AST::PathNode("PartialEq", {}) });
@@ -498,7 +507,7 @@ class Deriver_PartialEq:
rv.add_function(false, false, "eq", mv$(fcn));
return mv$(rv);
}
- AST::ExprNodeP compare_and_ret(Span sp, const ::std::string& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
+ AST::ExprNodeP compare_and_ret(Span sp, const RcString& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
{
return NEWNODE(If,
NEWNODE(BinOp, AST::ExprNode_BinOp::CMPNEQU, mv$(v1), mv$(v2)),
@@ -528,7 +537,7 @@ public:
(Tuple,
for( unsigned int idx = 0; idx < e.ents.size(); idx ++ )
{
- auto fld_name = FMT(idx);
+ auto fld_name = RcString::new_interned(FMT(idx));
nodes.push_back(this->compare_and_ret( sp, opts.core_name,
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), fld_name),
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("v" )), fld_name)
@@ -566,8 +575,8 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
- auto name_b = FMT("b" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
+ auto name_b = RcString::new_interned(FMT("b" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
pats_b.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF) );
nodes.push_back(this->compare_and_ret(sp, opts.core_name,
@@ -582,14 +591,14 @@ public:
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_b;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_b;
::std::vector<AST::ExprNodeP> nodes;
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
- auto name_b = FMT("b" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
+ auto name_b = RcString::new_interned(FMT("b" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
pats_b.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF)) );
nodes.push_back(this->compare_and_ret(sp, opts.core_name,
@@ -642,16 +651,7 @@ public:
class Deriver_PartialOrd:
public Deriver
{
- AST::Path get_path(const ::std::string core_name, ::std::string c1, ::std::string c2) const
- {
- return AST::Path(core_name, { AST::PathNode(c1, {}), AST::PathNode(c2, {}) });
- }
- AST::Path get_path(const ::std::string core_name, ::std::string c1, ::std::string c2, ::std::string c3) const
- {
- return AST::Path(core_name, { AST::PathNode(c1, {}), AST::PathNode(c2, {}), AST::PathNode(c3, {}) });
- }
-
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path(core_name, { AST::PathNode("cmp", {}), AST::PathNode("PartialOrd", {}) });
const AST::Path path_ordering(core_name, { AST::PathNode("cmp", {}), AST::PathNode("Ordering", {}) });
@@ -678,10 +678,10 @@ class Deriver_PartialOrd:
return mv$(rv);
}
- AST::ExprNodeP make_compare_and_ret(Span sp, const ::std::string& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
+ AST::ExprNodeP make_compare_and_ret(Span sp, const RcString& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
{
return NEWNODE(Match,
- NEWNODE(CallPath, this->get_path(core_name, "cmp", "PartialOrd", "partial_cmp"),
+ NEWNODE(CallPath, get_path(core_name, "cmp", "PartialOrd", "partial_cmp"),
::make_vec2(
NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(v1)),
NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(v2))
@@ -689,13 +689,13 @@ class Deriver_PartialOrd:
),
::make_vec3(
::AST::ExprNode_Match_Arm(
- ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, this->get_path(core_name, "option", "Option", "None")) ),
+ ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, get_path(core_name, "option", "Option", "None")) ),
nullptr,
- NEWNODE(Flow, AST::ExprNode_Flow::RETURN, "", NEWNODE(NamedValue, this->get_path(core_name, "option", "Option", "None")))
+ NEWNODE(Flow, AST::ExprNode_Flow::RETURN, "", NEWNODE(NamedValue, get_path(core_name, "option", "Option", "None")))
),
::AST::ExprNode_Match_Arm(
- ::make_vec1( AST::Pattern(AST::Pattern::TagNamedTuple(), sp, this->get_path(core_name, "option", "Option", "Some"),
- ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, this->get_path(core_name, "cmp", "Ordering", "Equal")) )
+ ::make_vec1( AST::Pattern(AST::Pattern::TagNamedTuple(), sp, get_path(core_name, "option", "Option", "Some"),
+ ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, get_path(core_name, "cmp", "Ordering", "Equal")) )
) ),
nullptr,
NEWNODE(Tuple, ::std::vector<AST::ExprNodeP>())
@@ -708,10 +708,10 @@ class Deriver_PartialOrd:
)
);
}
- AST::ExprNodeP make_ret_equal(const ::std::string& core_name) const
+ AST::ExprNodeP make_ret_equal(const RcString& core_name) const
{
- return NEWNODE(CallPath, this->get_path(core_name, "option", "Option", "Some"),
- ::make_vec1( NEWNODE(NamedValue, this->get_path(core_name, "cmp", "Ordering", "Equal")) )
+ return NEWNODE(CallPath, get_path(core_name, "option", "Option", "Some"),
+ ::make_vec1( NEWNODE(NamedValue, get_path(core_name, "cmp", "Ordering", "Equal")) )
);
}
public:
@@ -736,7 +736,7 @@ public:
(Tuple,
for( unsigned int idx = 0; idx < e.ents.size(); idx ++ )
{
- auto fld_name = FMT(idx);
+ auto fld_name = RcString::new_interned(FMT(idx));
nodes.push_back(this->make_compare_and_ret( sp, opts.core_name,
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), fld_name),
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("v" )), fld_name)
@@ -774,8 +774,8 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
- auto name_b = FMT("b" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
+ auto name_b = RcString::new_interned(FMT("b" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
pats_b.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF) );
@@ -791,14 +791,14 @@ public:
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_b;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_b;
::std::vector<AST::ExprNodeP> nodes;
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
- auto name_b = FMT("b" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
+ auto name_b = RcString::new_interned(FMT("b" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
pats_b.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF)) );
@@ -834,10 +834,10 @@ public:
// - Requires a way of emitting said intrinsic into the AST
// - LAZY WAY - hard-code ::"core"::intrinsics::discriminant_value
{
- auto code = NEWNODE(CallPath, this->get_path(opts.core_name, "cmp", "PartialOrd", "partial_cmp"),
+ auto code = NEWNODE(CallPath, get_path(opts.core_name, "cmp", "PartialOrd", "partial_cmp"),
::make_vec2(
- NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, this->get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("self")) )) ),
- NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, this->get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("v")) )) )
+ NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("self")) )) ),
+ NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("v")) )) )
)
);
::std::vector< AST::Pattern> pats = make_vec1( AST::Pattern() );
@@ -862,11 +862,11 @@ public:
class Deriver_Eq:
public Deriver
{
- AST::Path get_trait_path(const ::std::string& core_name) const {
+ AST::Path get_trait_path(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("cmp", {}), AST::PathNode("Eq", {}) });
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path(core_name);
@@ -894,6 +894,9 @@ class Deriver_Eq:
);
}
AST::ExprNodeP field(const ::std::string& name) const {
+ return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), RcString::new_interned(name));
+ }
+ AST::ExprNodeP field(const RcString& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
@@ -949,7 +952,7 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
@@ -958,12 +961,12 @@ public:
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
::std::vector<AST::ExprNodeP> nodes;
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
@@ -1007,16 +1010,7 @@ public:
class Deriver_Ord:
public Deriver
{
- AST::Path get_path(const ::std::string core_name, ::std::string c1, ::std::string c2) const
- {
- return AST::Path(core_name, { AST::PathNode(c1, {}), AST::PathNode(c2, {}) });
- }
- AST::Path get_path(const ::std::string core_name, ::std::string c1, ::std::string c2, ::std::string c3) const
- {
- return AST::Path(core_name, { AST::PathNode(c1, {}), AST::PathNode(c2, {}), AST::PathNode(c3, {}) });
- }
-
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path(core_name, { AST::PathNode("cmp", {}), AST::PathNode("Ord", {}) });
const AST::Path path_ordering(core_name, { AST::PathNode("cmp", {}), AST::PathNode("Ordering", {}) });
@@ -1040,10 +1034,10 @@ class Deriver_Ord:
return mv$(rv);
}
- AST::ExprNodeP make_compare_and_ret(Span sp, const ::std::string& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
+ AST::ExprNodeP make_compare_and_ret(Span sp, const RcString& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
{
return NEWNODE(Match,
- NEWNODE(CallPath, this->get_path(core_name, "cmp", "Ord", "cmp"),
+ NEWNODE(CallPath, get_path(core_name, "cmp", "Ord", "cmp"),
// TODO: Optional Ref?
::make_vec2(
NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(v1)),
@@ -1052,7 +1046,7 @@ class Deriver_Ord:
),
::make_vec2(
::AST::ExprNode_Match_Arm(
- ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, this->get_path(core_name, "cmp", "Ordering", "Equal")) ),
+ ::make_vec1( AST::Pattern(AST::Pattern::TagValue(), sp, get_path(core_name, "cmp", "Ordering", "Equal")) ),
nullptr,
NEWNODE(Tuple, ::std::vector<AST::ExprNodeP>())
),
@@ -1064,9 +1058,9 @@ class Deriver_Ord:
)
);
}
- AST::ExprNodeP make_ret_equal(const ::std::string& core_name) const
+ AST::ExprNodeP make_ret_equal(const RcString& core_name) const
{
- return NEWNODE(NamedValue, this->get_path(core_name, "cmp", "Ordering", "Equal"));
+ return NEWNODE(NamedValue, get_path(core_name, "cmp", "Ordering", "Equal"));
}
public:
const char* trait_name() const override { return "Ord"; }
@@ -1090,7 +1084,7 @@ public:
(Tuple,
for( unsigned int idx = 0; idx < e.ents.size(); idx ++ )
{
- auto fld_name = FMT(idx);
+ auto fld_name = RcString::new_interned(FMT(idx));
nodes.push_back(this->make_compare_and_ret( sp, opts.core_name,
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), fld_name),
NEWNODE(Field, NEWNODE(NamedValue, AST::Path("v" )), fld_name)
@@ -1128,8 +1122,8 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
- auto name_b = FMT("b" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
+ auto name_b = RcString::new_interned(FMT("b" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
pats_b.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF) );
@@ -1145,14 +1139,14 @@ public:
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_b;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_b;
::std::vector<AST::ExprNodeP> nodes;
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
- auto name_b = FMT("b" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
+ auto name_b = RcString::new_interned(FMT("b" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
pats_b.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_b, ::AST::PatternBinding::Type::REF)) );
@@ -1186,10 +1180,10 @@ public:
{
- auto code = NEWNODE(CallPath, this->get_path(opts.core_name, "cmp", "Ord", "cmp"),
+ auto code = NEWNODE(CallPath, get_path(opts.core_name, "cmp", "Ord", "cmp"),
::make_vec2(
- NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, this->get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("self")) )) ),
- NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, this->get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("v")) )) )
+ NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("self")) )) ),
+ NEWNODE(UniOp, AST::ExprNode_UniOp::REF, NEWNODE(CallPath, get_path(opts.core_name, "intrinsics", "discriminant_value"), make_vec1( NEWNODE(NamedValue, AST::Path("v")) )) )
)
);
::std::vector< AST::Pattern> pats = make_vec1( AST::Pattern() );
@@ -1214,14 +1208,14 @@ public:
class Deriver_Clone:
public Deriver
{
- AST::Path get_trait_path(const ::std::string& core_name) const {
+ AST::Path get_trait_path(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("clone", {}), AST::PathNode("Clone", {}) });
}
- AST::Path get_method_path(const ::std::string& core_name) const {
+ AST::Path get_method_path(const RcString& core_name) const {
return get_trait_path(core_name) + "clone";
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path(core_name);
@@ -1242,22 +1236,25 @@ class Deriver_Clone:
rv.add_function(false, false, "clone", mv$(fcn));
return mv$(rv);
}
- AST::ExprNodeP clone_val_ref(const ::std::string& core_name, AST::ExprNodeP val) const {
+ AST::ExprNodeP clone_val_ref(const RcString& core_name, AST::ExprNodeP val) const {
// TODO: Hack for zero-sized arrays? (Not a 1.19 feature)
return NEWNODE(CallPath,
this->get_method_path(core_name),
vec$( NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(val) ) )
);
}
- AST::ExprNodeP clone_val_direct(const ::std::string& core_name, AST::ExprNodeP val) const {
+ AST::ExprNodeP clone_val_direct(const RcString& core_name, AST::ExprNodeP val) const {
return NEWNODE(CallPath,
this->get_method_path(core_name),
vec$( mv$(val) )
);
}
- AST::ExprNodeP field(const ::std::string& name) const {
+ AST::ExprNodeP field(const RcString& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
+ AST::ExprNodeP field(const ::std::string& name) const {
+ return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), RcString::new_interned(name));
+ }
public:
const char* trait_name() const override { return "Clone"; }
@@ -1314,7 +1311,7 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->clone_val_direct(opts.core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
@@ -1323,12 +1320,12 @@ public:
code = NEWNODE(CallPath, base_path + v.m_name, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
::AST::ExprNode_StructLiteral::t_values vals;
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
vals.push_back({ {}, fld.m_name, this->clone_val_direct(opts.core_name, NEWNODE(NamedValue, AST::Path(name_a))) });
}
@@ -1383,11 +1380,11 @@ private:
class Deriver_Copy:
public Deriver
{
- AST::Path get_trait_path(const ::std::string& core_name) const {
+ AST::Path get_trait_path(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("marker", {}), AST::PathNode("Copy", {}) });
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path(core_name);
@@ -1418,14 +1415,14 @@ public:
class Deriver_Default:
public Deriver
{
- AST::Path get_trait_path(const ::std::string& core_name) const {
+ AST::Path get_trait_path(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("default", {}), AST::PathNode("Default", {}) });
}
- AST::Path get_method_path(const ::std::string& core_name) const {
+ AST::Path get_method_path(const RcString& core_name) const {
return AST::Path(AST::Path::TagUfcs(), ::TypeRef(Span()), get_trait_path(core_name), { AST::PathNode("default", {}) } );
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path(core_name);
@@ -1444,7 +1441,7 @@ class Deriver_Default:
rv.add_function(false, false, "default", mv$(fcn));
return mv$(rv);
}
- AST::ExprNodeP default_call(const ::std::string& core_name) const {
+ AST::ExprNodeP default_call(const RcString& core_name) const {
return NEWNODE(CallPath,
this->get_method_path(core_name),
{}
@@ -1493,17 +1490,17 @@ public:
class Deriver_Hash:
public Deriver
{
- AST::Path get_trait_path(const ::std::string& core_name) const {
+ AST::Path get_trait_path(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("hash", {}), AST::PathNode("Hash", {}) });
}
- AST::Path get_trait_path_Hasher(const ::std::string& core_name) const {
+ AST::Path get_trait_path_Hasher(const RcString& core_name) const {
return AST::Path(core_name, { AST::PathNode("hash", {}), AST::PathNode("Hasher", {}) });
}
- AST::Path get_method_path(const ::std::string& core_name) const {
+ AST::Path get_method_path(const RcString& core_name) const {
return get_trait_path(core_name) + "hash";
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path(core_name);
@@ -1530,18 +1527,21 @@ class Deriver_Hash:
rv.add_function(false, false, "hash", mv$(fcn));
return mv$(rv);
}
- AST::ExprNodeP hash_val_ref(const ::std::string& core_name, AST::ExprNodeP val) const {
+ AST::ExprNodeP hash_val_ref(const RcString& core_name, AST::ExprNodeP val) const {
return this->hash_val_direct(core_name, NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(val)) );
}
- AST::ExprNodeP hash_val_direct(const ::std::string& core_name, AST::ExprNodeP val) const {
+ AST::ExprNodeP hash_val_direct(const RcString& core_name, AST::ExprNodeP val) const {
return NEWNODE(CallPath,
this->get_method_path(core_name),
vec$( mv$(val), NEWNODE(NamedValue, AST::Path("state")) )
);
}
- AST::ExprNodeP field(const ::std::string& name) const {
+ AST::ExprNodeP field(const RcString& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
+ AST::ExprNodeP field(const std::string& name) const {
+ return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), RcString::new_interned(name));
+ }
public:
const char* trait_name() const override { return "Hash"; }
@@ -1596,7 +1596,7 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->hash_val_direct(opts.core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
@@ -1605,13 +1605,13 @@ public:
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
::std::vector< AST::ExprNodeP > nodes;
nodes.push_back( mv$(var_idx_hash) );
for( const auto& fld : e.m_fields )
{
- auto name_a = FMT("a" << fld.m_name);
+ auto name_a = RcString::new_interned(FMT("a" << fld.m_name));
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF)) );
nodes.push_back( this->hash_val_direct(opts.core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
@@ -1652,7 +1652,7 @@ class Deriver_RustcEncodable:
return get_trait_path() + "encode";
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path();
@@ -1689,9 +1689,12 @@ class Deriver_RustcEncodable:
AST::ExprNodeP enc_val_ref(AST::ExprNodeP val) const {
return this->enc_val_direct(NEWNODE(UniOp, AST::ExprNode_UniOp::REF, mv$(val)) );
}
- AST::ExprNodeP field(const ::std::string& name) const {
+ AST::ExprNodeP field(const RcString& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
+ AST::ExprNodeP field(::std::string name) const {
+ return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), RcString::new_interned(name));
+ }
AST::ExprNodeP enc_closure(Span sp, AST::ExprNodeP code) const {
return NEWNODE(Closure,
@@ -1699,7 +1702,7 @@ class Deriver_RustcEncodable:
mv$(code), false
);
}
- AST::ExprNodeP get_val_ok(const ::std::string& core_name) const {
+ AST::ExprNodeP get_val_ok(const RcString& core_name) const {
return NEWNODE(CallPath, AST::Path(core_name, {AST::PathNode("result",{}), AST::PathNode("Result",{}), AST::PathNode("Ok",{})}), vec$( NEWNODE(Tuple, {})) );
}
@@ -1708,7 +1711,7 @@ public:
AST::Impl handle_item(Span sp, const DeriveOpts& opts, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
- const ::std::string& struct_name = type.m_data.as_Path().path.nodes().back().name();
+ ::std::string struct_name = type.m_data.as_Path().path.nodes().back().name().c_str();
::std::vector<AST::ExprNodeP> nodes;
TU_MATCH(AST::StructData, (str.m_data), (e),
@@ -1720,7 +1723,12 @@ public:
{
nodes.push_back( NEWNODE(CallPath,
this->get_trait_path_Encoder() + "emit_struct_field",
- vec$( NEWNODE(NamedValue, AST::Path("s")), NEWNODE(String, fld.m_name), NEWNODE(Integer, idx, CORETYPE_UINT), this->enc_closure( sp, this->enc_val_ref(this->field(fld.m_name)) ) )
+ vec$(
+ NEWNODE(NamedValue, AST::Path("s")),
+ NEWNODE(String, fld.m_name.c_str()),
+ NEWNODE(Integer, idx, CORETYPE_UINT),
+ this->enc_closure( sp, this->enc_val_ref(this->field(fld.m_name)) )
+ )
) );
idx ++;
}
@@ -1778,7 +1786,7 @@ public:
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_variant",
vec$(
NEWNODE(NamedValue, AST::Path("s")),
- NEWNODE(String, v.m_name),
+ NEWNODE(String, v.m_name.c_str()),
NEWNODE(Integer, var_idx, CORETYPE_UINT),
NEWNODE(Integer, 0, CORETYPE_UINT),
this->enc_closure(sp, this->get_val_ok(opts.core_name))
@@ -1792,7 +1800,7 @@ public:
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
- auto name_a = FMT("a" << idx);
+ auto name_a = RcString::new_interned(FMT("a" << idx));
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), sp, name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_variant_arg",
vec$(
@@ -1807,7 +1815,7 @@ public:
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_variant",
vec$(
NEWNODE(NamedValue, AST::Path("s")),
- NEWNODE(String, v.m_name),
+ NEWNODE(String, v.m_name.c_str()),
NEWNODE(Integer, var_idx, CORETYPE_UINT),
NEWNODE(Integer, e.m_sub_types.size(), CORETYPE_UINT),
this->enc_closure(sp, NEWNODE(Block, mv$(nodes)))
@@ -1816,19 +1824,19 @@ public:
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), sp, base_path + v.m_name, mv$(pats_a));
),
(Struct,
- ::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
+ ::std::vector< ::std::pair<RcString, AST::Pattern> > pats_a;
::std::vector< AST::ExprNodeP > nodes;
unsigned int idx = 0;
for( const auto& fld : e.m_fields )
{
- auto name_a = Ident( FMT("a" << fld.m_name) );
+ auto name_a = Ident( RcString::new_interned(FMT("a" << fld.m_name)) );
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), sp, Ident(name_a), ::AST::PatternBinding::Type::REF)) );
nodes.push_back( NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_struct_variant_field",
vec$(
NEWNODE(NamedValue, AST::Path("s")),
- NEWNODE(String, fld.m_name),
+ NEWNODE(String, fld.m_name.c_str()),
NEWNODE(Integer, idx, CORETYPE_UINT),
this->enc_closure(sp, this->enc_val_direct(NEWNODE(NamedValue, AST::Path(name_a.name))))
)
@@ -1841,7 +1849,7 @@ public:
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_struct_variant",
vec$(
NEWNODE(NamedValue, AST::Path("s")),
- NEWNODE(String, v.m_name),
+ NEWNODE(String, v.m_name.c_str()),
NEWNODE(Integer, var_idx, CORETYPE_UINT),
NEWNODE(Integer, e.m_fields.size(), CORETYPE_UINT),
this->enc_closure(sp, NEWNODE(Block, mv$(nodes)))
@@ -1862,7 +1870,7 @@ public:
auto node_match = NEWNODE(Match, NEWNODE(NamedValue, AST::Path("self")), mv$(arms));
- const ::std::string& enum_name = type.m_data.as_Path().path.nodes().back().name();
+ ::std::string enum_name = type.m_data.as_Path().path.nodes().back().name().c_str();
auto node = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum",
vec$( NEWNODE(NamedValue, AST::Path("s")), NEWNODE(String, enum_name), this->enc_closure(sp, mv$(node_match)) )
);
@@ -1885,11 +1893,11 @@ class Deriver_RustcDecodable:
return get_trait_path() + "decode";
}
- AST::Impl make_ret(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
+ AST::Impl make_ret(Span sp, const RcString& core_name, const AST::GenericParams& p, const TypeRef& type, ::std::vector<TypeRef> types_to_bound, AST::ExprNodeP node) const
{
const AST::Path trait_path = this->get_trait_path();
- AST::Path result_path = AST::Path(core_name, { AST::PathNode("result", {}), AST::PathNode("Result", {}) });
+ AST::Path result_path = AST::Path(core_name, { AST::PathNode(RcString::new_interned("result"), {}), AST::PathNode(RcString::new_interned("Result"), {}) });
result_path.nodes()[1].args().m_types.push_back( TypeRef(sp, "Self", 0xFFFF) );
result_path.nodes()[1].args().m_types.push_back( TypeRef(sp, AST::Path(AST::Path::TagUfcs(), TypeRef(sp, "D", 0x100|0), this->get_trait_path_Decoder(), { AST::PathNode("Error",{}) })) );
@@ -1920,7 +1928,7 @@ class Deriver_RustcDecodable:
return NEWNODE(CallPath, this->get_method_path(), vec$( NEWNODE(NamedValue, AST::Path("d")) ));
}
AST::ExprNodeP field(const ::std::string& name) const {
- return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
+ return NEWNODE(Field, NEWNODE(NamedValue, AST::Path(RcString::new_interned("self"))), RcString::new_interned(name));
}
AST::ExprNodeP dec_closure(Span sp, AST::ExprNodeP code) const {
@@ -1929,8 +1937,8 @@ class Deriver_RustcDecodable:
mv$(code), false
);
}
- AST::ExprNodeP get_val_err_str(const ::std::string& core_name, ::std::string err_str) const {
- return NEWNODE(CallPath, AST::Path(core_name, {AST::PathNode("result",{}), AST::PathNode("Result",{}), AST::PathNode("Err",{})}), vec$(
+ AST::ExprNodeP get_val_err_str(const RcString& core_name, ::std::string err_str) const {
+ return NEWNODE(CallPath, get_path(core_name, "result", "Result", "Err"), vec$(
NEWNODE(CallMethod,
NEWNODE(NamedValue, AST::Path("d")),
AST::PathNode("error"),
@@ -1938,10 +1946,10 @@ class Deriver_RustcDecodable:
)
) );
}
- AST::ExprNodeP get_val_ok(const ::std::string& core_name, AST::ExprNodeP inner) const {
- return NEWNODE(CallPath, AST::Path(core_name, {AST::PathNode("result",{}), AST::PathNode("Result",{}), AST::PathNode("Ok",{})}), vec$( mv$(inner) ) );
+ AST::ExprNodeP get_val_ok(const RcString& core_name, AST::ExprNodeP inner) const {
+ return NEWNODE(CallPath, get_path(core_name, "result", "Result", "Ok"), vec$( mv$(inner) ) );
}
- AST::ExprNodeP get_val_ok_unit(const ::std::string& core_name) const {
+ AST::ExprNodeP get_val_ok_unit(const RcString& core_name) const {
return get_val_ok(core_name, NEWNODE(Tuple, {}));
}
@@ -1951,7 +1959,7 @@ public:
AST::Impl handle_item(Span sp, const DeriveOpts& opts, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
AST::Path base_path = type.m_data.as_Path().path;
- const ::std::string& struct_name = type.m_data.as_Path().path.nodes().back().name();
+ ::std::string struct_name = type.m_data.as_Path().path.nodes().back().name().c_str();
AST::ExprNodeP node_v;
TU_MATCH(AST::StructData, (str.m_data), (e),
@@ -1964,7 +1972,7 @@ public:
{
vals.push_back({ {}, fld.m_name, NEWNODE(UniOp, ::AST::ExprNode_UniOp::QMARK, NEWNODE(CallPath,
this->get_trait_path_Decoder() + "read_struct_field",
- vec$( NEWNODE(NamedValue, AST::Path("d")), NEWNODE(String, fld.m_name), NEWNODE(Integer, idx, CORETYPE_UINT), this->dec_closure( sp, this->dec_val() ) )
+ vec$( NEWNODE(NamedValue, AST::Path("d")), NEWNODE(String, fld.m_name.c_str()), NEWNODE(Integer, idx, CORETYPE_UINT), this->dec_closure( sp, this->dec_val() ) )
)) });
idx ++;
}
@@ -2053,7 +2061,7 @@ public:
vals.push_back({ {}, fld.m_name, NEWNODE(UniOp, ::AST::ExprNode_UniOp::QMARK, NEWNODE(CallPath, this->get_trait_path_Decoder() + "read_enum_struct_variant_field",
vec$(
NEWNODE(NamedValue, AST::Path("d")),
- NEWNODE(String, fld.m_name),
+ NEWNODE(String, fld.m_name.c_str()),
NEWNODE(Integer, idx, CORETYPE_UINT),
this->dec_closure(sp, this->dec_val())
)
@@ -2073,7 +2081,7 @@ public:
nullptr,
this->get_val_ok(opts.core_name, mv$(code))
));
- var_name_strs.push_back( NEWNODE(String, v.m_name) );
+ var_name_strs.push_back( NEWNODE(String, v.m_name.c_str()) );
}
// Default arm
@@ -2095,7 +2103,7 @@ public:
mv$(node_match),
false
);
- const ::std::string& enum_name = type.m_data.as_Path().path.nodes().back().name();
+ ::std::string enum_name = type.m_data.as_Path().path.nodes().back().name().c_str();
auto node_rev = NEWNODE(CallPath, this->get_trait_path_Decoder() + "read_enum_variant",
vec$(
@@ -2117,7 +2125,7 @@ public:
// --------------------------------------------------------------------
// Select and dispatch the correct derive() handler
// --------------------------------------------------------------------
-static const Deriver* find_impl(const ::std::string& trait_name)
+static const Deriver* find_impl(const RcString& trait_name)
{
#define _(obj) if(trait_name == obj.trait_name()) return &obj;
_(g_derive_debug)
@@ -2158,7 +2166,7 @@ static void derive_item(const Span& sp, const AST::Crate& crate, AST::Module& mo
attr.items()
};
- ::std::vector< ::std::string> missing_handlers;
+ ::std::vector< RcString> missing_handlers;
for( const auto& trait : attr.items() )
{
DEBUG("- " << trait.name());
@@ -2182,7 +2190,7 @@ static void derive_item(const Span& sp, const AST::Crate& crate, AST::Module& mo
}
else {
// proc_macro - Invoke the handler.
- auto lex = ProcMacro_Invoke(sp, crate, mac_path.path, path.nodes().back().name(), item);
+ auto lex = ProcMacro_Invoke(sp, crate, mac_path.path, path.nodes().back().name().c_str(), item);
if( lex )
{
Parse_ModRoot_Items(*lex, mod);
diff --git a/src/expand/env.cpp b/src/expand/env.cpp
index f4577ef1..825c895a 100644
--- a/src/expand/env.cpp
+++ b/src/expand/env.cpp
@@ -34,48 +34,44 @@ namespace {
class CExpanderEnv:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "env! doesn't take an ident");
::std::string varname = get_string(sp, crate, mod, tt);
const char* var_val_cstr = getenv(varname.c_str());
if( !var_val_cstr ) {
ERROR(sp, E0000, "Environment variable '" << varname << "' not defined");
}
- return box$( TTStreamO(sp, TokenTree(Token(TOK_STRING, var_val_cstr))) );
+ return box$( TTStreamO(sp, TokenTree(Token(TOK_STRING, ::std::string(var_val_cstr)))) );
}
};
class CExpanderOptionEnv:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "option_env! doesn't take an ident");
::std::string varname = get_string(sp, crate, mod, tt);
const char* var_val_cstr = getenv(varname.c_str());
if( !var_val_cstr ) {
::std::vector< TokenTree> rv;
rv.reserve(7);
- rv.push_back( Token(TOK_IDENT, "None") );
+ rv.push_back( Token(TOK_IDENT, RcString::new_interned("None")) );
rv.push_back( Token(TOK_DOUBLE_COLON) );
rv.push_back( Token(TOK_LT) );
rv.push_back( Token(TOK_AMP) );
- rv.push_back( Token(TOK_LIFETIME, "static") );
- rv.push_back( Token(TOK_IDENT, "str") );
+ rv.push_back( Token(TOK_LIFETIME, RcString::new_interned("static")) );
+ rv.push_back( Token(TOK_IDENT, RcString::new_interned("str")) );
rv.push_back( Token(TOK_GT) );
return box$( TTStreamO(sp, TokenTree( {}, mv$(rv) )) );
}
else {
::std::vector< TokenTree> rv;
rv.reserve(4);
- rv.push_back( Token(TOK_IDENT, "Some") );
+ rv.push_back( Token(TOK_IDENT, RcString::new_interned("Some")) );
rv.push_back( Token(TOK_PAREN_OPEN) );
- rv.push_back( Token(TOK_STRING, var_val_cstr) );
+ rv.push_back( Token(TOK_STRING, ::std::string(var_val_cstr)) );
rv.push_back( Token(TOK_PAREN_CLOSE) );
return box$( TTStreamO(sp, TokenTree( {}, mv$(rv) )) );
}
diff --git a/src/expand/file_line.cpp b/src/expand/file_line.cpp
index 2bf85ffd..09d3e6b2 100644
--- a/src/expand/file_line.cpp
+++ b/src/expand/file_line.cpp
@@ -23,16 +23,16 @@ namespace {
class CExpanderFile:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- return box$( TTStreamO(sp, TokenTree(Token(TOK_STRING, get_top_span(sp).filename.c_str()))) );
+ return box$( TTStreamO(sp, TokenTree(Token(TOK_STRING, ::std::string(get_top_span(sp).filename.c_str())))) );
}
};
class CExpanderLine:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
return box$( TTStreamO(sp, TokenTree(Token((uint64_t)get_top_span(sp).start_line, CORETYPE_U32))) );
}
@@ -41,7 +41,7 @@ class CExpanderLine:
class CExpanderColumn:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
return box$( TTStreamO(sp, TokenTree(Token((uint64_t)get_top_span(sp).start_ofs, CORETYPE_U32))) );
}
@@ -49,7 +49,7 @@ class CExpanderColumn:
class CExpanderUnstableColumn:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
return box$( TTStreamO(sp, TokenTree(Token((uint64_t)get_top_span(sp).start_ofs, CORETYPE_U32))) );
}
@@ -58,13 +58,13 @@ class CExpanderUnstableColumn:
class CExpanderModulePath:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
::std::string path_str;
for(const auto& comp : mod.path().nodes()) {
if( &comp != &mod.path().nodes().front() )
path_str += "::";
- path_str += comp.name();
+ path_str += comp.name().c_str();
}
return box$( TTStreamO(sp, TokenTree( Token(TOK_STRING, mv$(path_str)) )) );
}
diff --git a/src/expand/format_args.cpp b/src/expand/format_args.cpp
index d79fd9d5..7f33eb6d 100644
--- a/src/expand/format_args.cpp
+++ b/src/expand/format_args.cpp
@@ -189,11 +189,11 @@ namespace {
::std::tuple< ::std::vector<FmtFrag>, ::std::string> parse_format_string(
const Span& sp,
const ::std::string& format_string,
- const ::std::map< ::std::string,unsigned int>& named,
+ const ::std::map<RcString,unsigned int>& named,
unsigned int n_free
)
{
- unsigned int n_named = named.size();
+ //unsigned int n_named = named.size();
unsigned int next_free = 0;
::std::vector<FmtFrag> frags;
@@ -256,7 +256,7 @@ namespace {
while( isalnum(*s) || *s == '_' || (*s < 0 || *s > 127) ) {
s ++;
}
- ::std::string ident { start, s };
+ auto ident = RcString(start, s - start);
auto it = named.find(ident);
if( it == named.end() )
ERROR(sp, E0000, "Named argument '"<<ident<<"' not found");
@@ -359,7 +359,7 @@ namespace {
}
if( *s == '$' )
{
- ::std::string ident { start, s };
+ auto ident = RcString(start, s - start);
auto it = named.find(ident);
if( it == named.end() )
ERROR(sp, E0000, "Named argument '"<<ident<<"' not found");
@@ -464,6 +464,9 @@ namespace {
}
namespace {
+ Token ident(const char* s) {
+ return Token(TOK_IDENT, RcString::new_interned(s));
+ }
void push_path(::std::vector<TokenTree>& toks, const AST::Crate& crate, ::std::initializer_list<const char*> il)
{
switch(crate.m_load_std)
@@ -472,17 +475,17 @@ namespace {
break;
case ::AST::Crate::LOAD_CORE:
toks.push_back( TokenTree(TOK_DOUBLE_COLON) );
- toks.push_back( Token(TOK_IDENT, "core") );
+ toks.push_back( ident("core") );
break;
case ::AST::Crate::LOAD_STD:
toks.push_back( TokenTree(TOK_DOUBLE_COLON) );
- toks.push_back( Token(TOK_IDENT, "std") );
+ toks.push_back( ident("std") );
break;
}
for(auto ent : il)
{
toks.push_back( TokenTree(TOK_DOUBLE_COLON) );
- toks.push_back( Token(TOK_IDENT, ent) );
+ toks.push_back( ident(ent) );
}
}
void push_toks(::std::vector<TokenTree>& toks, Token t1) {
@@ -519,7 +522,7 @@ namespace {
const auto& format_string_sp = format_string_np->span();
const auto& format_string = format_string_np->m_value;
- ::std::map< ::std::string, unsigned int> named_args_index;
+ ::std::map<RcString, unsigned int> named_args_index;
::std::vector<TokenTree> named_args;
::std::vector<TokenTree> free_args;
@@ -535,7 +538,7 @@ namespace {
if( lex.lookahead(0) == TOK_IDENT && lex.lookahead(1) == TOK_EQUAL )
{
GET_CHECK_TOK(tok, lex, TOK_IDENT);
- auto name = mv$(tok.str());
+ auto name = tok.istr();
GET_CHECK_TOK(tok, lex, TOK_EQUAL);
@@ -600,7 +603,7 @@ namespace {
toks.push_back( TokenTree(TOK_PAREN_OPEN) );
for(unsigned int i = 0; i < free_args.size() + named_args.size(); i ++ )
{
- toks.push_back( Token(TOK_IDENT, FMT("a" << i)) );
+ toks.push_back( ident(FMT("a" << i).c_str()) );
toks.push_back( TokenTree(TOK_COMMA) );
}
toks.push_back( TokenTree(TOK_PAREN_CLOSE) );
@@ -612,13 +615,13 @@ namespace {
// - Contains N+1 entries, where N is the number of fragments
{
toks.push_back( TokenTree(TOK_RWORD_STATIC) );
- toks.push_back( Token(TOK_IDENT, "FRAGMENTS") );
+ toks.push_back( ident("FRAGMENTS") );
toks.push_back( TokenTree(TOK_COLON) );
toks.push_back( TokenTree(TOK_SQUARE_OPEN) );
toks.push_back( Token(TOK_AMP) );
- toks.push_back( Token(TOK_LIFETIME, "static") );
- toks.push_back( Token(TOK_IDENT, "str") );
+ toks.push_back( Token(TOK_LIFETIME, RcString::new_interned("static")) );
+ toks.push_back( ident("str") );
toks.push_back( Token(TOK_SEMICOLON) );
toks.push_back( Token(static_cast<uint64_t>(fragments.size() + 1), CORETYPE_UINT) );
toks.push_back( TokenTree(TOK_SQUARE_CLOSE) );
@@ -644,7 +647,7 @@ namespace {
toks.push_back( TokenTree(TOK_PAREN_OPEN) );
{
toks.push_back( TokenTree(TOK_AMP) );
- toks.push_back( Token(TOK_IDENT, "FRAGMENTS") );
+ toks.push_back( ident("FRAGMENTS") );
toks.push_back( TokenTree(TOK_COMMA) );
toks.push_back( TokenTree(TOK_AMP) );
@@ -653,7 +656,7 @@ namespace {
{
push_path(toks, crate, {"fmt", "ArgumentV1", "new"});
toks.push_back( Token(TOK_PAREN_OPEN) );
- toks.push_back( Token(TOK_IDENT, FMT("a" << frag.arg_index)) );
+ toks.push_back( ident( FMT("a" << frag.arg_index).c_str() ) );
toks.push_back( TokenTree(TOK_COMMA) );
@@ -678,7 +681,7 @@ namespace {
toks.push_back( TokenTree(TOK_PAREN_OPEN) );
{
toks.push_back( TokenTree(TOK_AMP) );
- toks.push_back( Token(TOK_IDENT, "FRAGMENTS") );
+ toks.push_back( ident("FRAGMENTS") );
toks.push_back( TokenTree(TOK_COMMA) );
// TODO: Fragments to format
@@ -689,7 +692,7 @@ namespace {
{
push_path(toks, crate, {"fmt", "ArgumentV1", "new"});
toks.push_back( Token(TOK_PAREN_OPEN) );
- toks.push_back( Token(TOK_IDENT, FMT("a" << frag.arg_index)) );
+ toks.push_back( ident(FMT("a" << frag.arg_index).c_str()) );
toks.push_back( TokenTree(TOK_COMMA) );
@@ -707,17 +710,17 @@ namespace {
push_path(toks, crate, {"fmt", "rt", "v1", "Argument"});
toks.push_back( TokenTree(TOK_BRACE_OPEN) );
- push_toks(toks, Token(TOK_IDENT, "position"), TOK_COLON );
+ push_toks(toks, ident("position"), TOK_COLON );
push_path(toks, crate, {"fmt", "rt", "v1", "Position", "Next"});
push_toks(toks, TOK_COMMA);
- push_toks(toks, Token(TOK_IDENT, "format"), TOK_COLON );
+ push_toks(toks, ident("format"), TOK_COLON );
push_path(toks, crate, {"fmt", "rt", "v1", "FormatSpec"});
toks.push_back( TokenTree(TOK_BRACE_OPEN) );
{
- push_toks(toks, Token(TOK_IDENT, "fill"), TOK_COLON, Token(uint64_t(frag.args.align_char), CORETYPE_CHAR), TOK_COMMA );
+ push_toks(toks, ident("fill"), TOK_COLON, Token(uint64_t(frag.args.align_char), CORETYPE_CHAR), TOK_COMMA );
- push_toks(toks, Token(TOK_IDENT, "align"), TOK_COLON);
+ push_toks(toks, ident("align"), TOK_COLON);
const char* align_var_name = nullptr;
switch( frag.args.align )
{
@@ -729,19 +732,19 @@ namespace {
push_path(toks, crate, {"fmt", "rt", "v1", "Alignment", align_var_name});
push_toks(toks, TOK_COMMA);
- push_toks(toks, Token(TOK_IDENT, "flags"), TOK_COLON);
+ push_toks(toks, ident("flags"), TOK_COLON);
uint64_t flags = 0;
if(frag.args.alternate)
flags |= 1 << 2;
push_toks(toks, Token(uint64_t(flags), CORETYPE_U32));
push_toks(toks, TOK_COMMA);
- push_toks(toks, Token(TOK_IDENT, "precision"), TOK_COLON );
+ push_toks(toks, ident("precision"), TOK_COLON );
if( frag.args.prec_is_arg || frag.args.prec != 0 ) {
push_path(toks, crate, {"fmt", "rt", "v1", "Count", "Is"});
push_toks(toks, TOK_PAREN_OPEN);
if( frag.args.prec_is_arg ) {
- push_toks(toks, TOK_STAR, Token(TOK_IDENT, FMT("a" << frag.args.prec)) );
+ push_toks(toks, TOK_STAR, ident(FMT("a" << frag.args.prec).c_str()) );
}
else {
push_toks(toks, Token(uint64_t(frag.args.prec), CORETYPE_UINT) );
@@ -753,12 +756,12 @@ namespace {
}
toks.push_back( TokenTree(TOK_COMMA) );
- push_toks(toks, Token(TOK_IDENT, "width"), TOK_COLON );
+ push_toks(toks, ident("width"), TOK_COLON );
if( frag.args.width_is_arg || frag.args.width != 0 ) {
push_path(toks, crate, {"fmt", "rt", "v1", "Count", "Is"});
push_toks(toks, TOK_PAREN_OPEN);
if( frag.args.width_is_arg ) {
- push_toks(toks, TOK_STAR, Token(TOK_IDENT, FMT("a" << frag.args.width)) );
+ push_toks(toks, TOK_STAR, ident(FMT("a" << frag.args.width).c_str()) );
}
else {
push_toks(toks, Token(uint64_t(frag.args.width), CORETYPE_UINT) );
@@ -791,14 +794,12 @@ namespace {
class CFormatArgsExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
auto lex = TTStream(sp, tt);
lex.parse_state().module = &mod;
- if( ident != "" )
- ERROR(sp, E0000, "format_args! doesn't take an ident");
return expand_format_args(sp, crate, lex, /*add_newline=*/false);
}
@@ -807,14 +808,12 @@ class CFormatArgsExpander:
class CFormatArgsNlExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
auto lex = TTStream(sp, tt);
lex.parse_state().module = &mod;
- if( ident != "" )
- ERROR(sp, E0000, "format_args_nl! doesn't take an ident");
return expand_format_args(sp, crate, lex, /*add_newline=*/true);
}
diff --git a/src/expand/include.cpp b/src/expand/include.cpp
index 8078d5d0..14a7bc7b 100644
--- a/src/expand/include.cpp
+++ b/src/expand/include.cpp
@@ -64,11 +64,8 @@ namespace {
class CIncludeExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "include! doesn't take an ident");
-
Token tok;
auto lex = TTStream(sp, tt);
@@ -91,11 +88,8 @@ class CIncludeExpander:
class CIncludeBytesExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "include_bytes! doesn't take an ident");
-
Token tok;
auto lex = TTStream(sp, tt);
@@ -121,11 +115,8 @@ class CIncludeBytesExpander:
class CIncludeStrExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "include_str! doesn't take an ident");
-
Token tok;
auto lex = TTStream(sp, tt);
diff --git a/src/expand/macro_rules.cpp b/src/expand/macro_rules.cpp
index 3bacfcf7..88b7fc88 100644
--- a/src/expand/macro_rules.cpp
+++ b/src/expand/macro_rules.cpp
@@ -21,11 +21,12 @@
class CMacroRulesExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const ::AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
+ {
+ ERROR(sp, E0000, "macro_rules! requires an identifier" );
+ }
+ ::std::unique_ptr<TokenStream> expand_ident(const Span& sp, const ::AST::Crate& crate, const RcString& ident, const TokenTree& tt, AST::Module& mod) override
{
- if( ident == "" )
- ERROR(sp, E0000, "macro_rules! requires an identifier" );
-
DEBUG("Parsing macro_rules! " << ident);
TTStream lex(sp, tt);
auto mac = Parse_MacroRules(lex);
@@ -48,7 +49,7 @@ class CMacroUseHandler:
// Just ignore
)
else TU_IFLET( ::AST::Item, i, Crate, ec_name,
- const auto& ec = crate.m_extern_crates.at(ec_name.name);
+ const auto& ec = crate.m_extern_crates.at(ec_name.name.c_str());
if( mi.has_sub_items() )
{
TODO(sp, "Named import from extern crate");
@@ -61,7 +62,7 @@ class CMacroUseHandler:
});
for(const auto& p : ec.m_hir->m_proc_macros)
{
- mod.m_macro_imports.push_back({ false, p.path.m_components.back(), p.path.m_components, nullptr });
+ mod.m_macro_imports.push_back(AST::Module::MacroImport{ false, p.path.m_components.back(), p.path.m_components, nullptr });
mod.m_macro_imports.back().path.insert( mod.m_macro_imports.back().path.begin(), p.path.m_crate_name );
}
}
@@ -153,7 +154,7 @@ class CMacroReexportHandler:
}
const auto& crate_name = i.as_Crate().name;
- auto& ext_crate = *crate.m_extern_crates.at(crate_name).m_hir;
+ auto& ext_crate = *crate.m_extern_crates.at(crate_name.c_str()).m_hir;
if( mi.has_sub_items() )
{
diff --git a/src/expand/mod.cpp b/src/expand/mod.cpp
index bc51e1ff..e3cef375 100644
--- a/src/expand/mod.cpp
+++ b/src/expand/mod.cpp
@@ -56,7 +56,7 @@ void ExpandDecorator::unexpected(const Span& sp, const AST::Attribute& mi, const
void Expand_Attr(const Span& sp, const ::AST::Attribute& a, AttrStage stage, ::std::function<void(const Span& sp, const ExpandDecorator& d,const ::AST::Attribute& a)> f)
{
for( auto& d : g_decorators ) {
- if( d.first == a.name() ) {
+ if( a.name() == d.first ) {
DEBUG("#[" << d.first << "] " << (int)d.second->stage() << "-" << (int)stage);
if( d.second->stage() == stage ) {
f(sp, *d.second, a);
@@ -94,7 +94,7 @@ void Expand_Attrs(::AST::AttributeList& attrs, AttrStage stage, ::AST::Crate& c
::std::unique_ptr<TokenStream> Expand_Macro_Inner(
const ::AST::Crate& crate, LList<const AST::Module*> modstack, ::AST::Module& mod,
- Span mi_span, const ::std::string& name, const ::std::string& input_ident, TokenTree& input_tt
+ Span mi_span, const RcString& name, const RcString& input_ident, TokenTree& input_tt
)
{
if( name == "" ) {
@@ -105,7 +105,10 @@ void Expand_Attrs(::AST::AttributeList& attrs, AttrStage stage, ::AST::Crate& c
{
if( name == m.first )
{
- auto e = m.second->expand(mi_span, crate, input_ident, input_tt, mod);
+ auto e = input_ident == ""
+ ? m.second->expand(mi_span, crate, input_tt, mod)
+ : m.second->expand_ident(mi_span, crate, input_ident, input_tt, mod)
+ ;
return e;
}
}
@@ -152,7 +155,7 @@ void Expand_Attrs(::AST::AttributeList& attrs, AttrStage stage, ::AST::Crate& c
}
::std::unique_ptr<TokenStream> Expand_Macro(
const ::AST::Crate& crate, LList<const AST::Module*> modstack, ::AST::Module& mod,
- Span mi_span, const ::std::string& name, const ::std::string& input_ident, TokenTree& input_tt
+ Span mi_span, const RcString& name, const RcString& input_ident, TokenTree& input_tt
)
{
auto rv = Expand_Macro_Inner(crate, modstack, mod, mi_span, name, input_ident, input_tt);
@@ -348,7 +351,7 @@ struct CExpandExpr:
::std::unique_ptr<::AST::ExprNode> replacement;
// Stack of `try { ... }` blocks (the string is the loop label for the desugaring)
- ::std::vector< ::std::string> m_try_stack;
+ ::std::vector<RcString> m_try_stack;
unsigned m_try_index = 0;
AST::ExprNode_Block* current_block = nullptr;
@@ -559,7 +562,7 @@ struct CExpandExpr:
// }
// ```
// NOTE: MIR lowering and HIR typecheck need to know to skip these (OR resolve should handle naming all loop blocks)
- m_try_stack.push_back(FMT("#try" << m_try_index++));
+ m_try_stack.push_back(RcString::new_interned(FMT("#try" << m_try_index++)));
this->visit_nodelete(node, node.m_inner);
auto loop_name = mv$(m_try_stack.back());
m_try_stack.pop_back();
@@ -858,7 +861,7 @@ struct CExpandExpr:
nullptr,
::AST::ExprNodeP(new ::AST::ExprNode_Flow(
(m_try_stack.empty() ? ::AST::ExprNode_Flow::RETURN : ::AST::ExprNode_Flow::BREAK), // NOTE: uses `break 'tryblock` instead of return if in a try block.
- (m_try_stack.empty() ? "" : m_try_stack.back()),
+ (m_try_stack.empty() ? RcString("") : m_try_stack.back()),
::AST::ExprNodeP(new ::AST::ExprNode_CallPath(
::AST::Path(path_Try_from_error),
::make_vec1(
@@ -1415,7 +1418,7 @@ void Expand(::AST::Crate& crate)
for( auto& a : crate.m_attrs.m_items )
{
for( auto& d : g_decorators ) {
- if( d.first == a.name() && d.second->stage() == AttrStage::Pre ) {
+ if( a.name() == d.first && d.second->stage() == AttrStage::Pre ) {
//d.second->handle(a, crate, ::AST::Path(), crate.m_root_module, crate.m_root_module);
}
}
diff --git a/src/expand/proc_macro.cpp b/src/expand/proc_macro.cpp
index f0f28f5a..24cd41d9 100644
--- a/src/expand/proc_macro.cpp
+++ b/src/expand/proc_macro.cpp
@@ -49,13 +49,13 @@ public:
{
if( attr.items()[i].name() == "attributes") {
for(const auto& si : attr.items()[i].items()) {
- attributes.push_back( si.name() );
+ attributes.push_back( si.name().c_str() );
}
}
}
// TODO: Store attributes for later use.
- crate.m_proc_macros.push_back(AST::ProcMacroDef { FMT("derive#" << trait_name), path, mv$(attributes) });
+ crate.m_proc_macros.push_back(AST::ProcMacroDef { RcString::new_interned(FMT("derive#" << trait_name)), path, mv$(attributes) });
}
};
@@ -100,7 +100,7 @@ void Expand_ProcMacro(::AST::Crate& crate)
{
::AST::ExprNode_StructLiteral::t_values desc_vals;
// `name: "foo",`
- desc_vals.push_back({ {}, "name", NEWNODE(_String, desc.name) });
+ desc_vals.push_back({ {}, "name", NEWNODE(_String, desc.name.c_str()) });
// `handler`: ::foo
desc_vals.push_back({ {}, "handler", NEWNODE(_NamedValue, AST::Path(desc.path)) });
@@ -211,7 +211,7 @@ public:
void send_float(eCoreType ct, double v);
//void send_fragment();
- bool attr_is_used(const ::std::string& n) const {
+ bool attr_is_used(const RcString& n) const {
return ::std::find(m_proc_macro_desc.attributes.begin(), m_proc_macro_desc.attributes.end(), n) != m_proc_macro_desc.attributes.end();
}
@@ -229,7 +229,7 @@ private:
uint64_t recv_v128u();
};
-ProcMacroInv ProcMacro_Invoke_int(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path)
+ProcMacroInv ProcMacro_Invoke_int(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path)
{
// 1. Locate macro in HIR list
const auto& crate_name = mac_path.front();
@@ -745,7 +745,7 @@ namespace {
}
};
}
-::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& item_name, const ::AST::Struct& i)
+::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& item_name, const ::AST::Struct& i)
{
// 1. Create ProcMacroInv instance
auto pmi = ProcMacro_Invoke_int(sp, crate, mac_path);
@@ -757,7 +757,7 @@ namespace {
// 3. Return boxed invocation instance
return box$(pmi);
}
-::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& item_name, const ::AST::Enum& i)
+::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& item_name, const ::AST::Enum& i)
{
// 1. Create ProcMacroInv instance
auto pmi = ProcMacro_Invoke_int(sp, crate, mac_path);
@@ -769,7 +769,7 @@ namespace {
// 3. Return boxed invocation instance
return box$(pmi);
}
-::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& item_name, const ::AST::Union& i)
+::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& item_name, const ::AST::Union& i)
{
// 1. Create ProcMacroInv instance
auto pmi = ProcMacro_Invoke_int(sp, crate, mac_path);
diff --git a/src/expand/proc_macro.hpp b/src/expand/proc_macro.hpp
index 8c5b71c7..e66bf037 100644
--- a/src/expand/proc_macro.hpp
+++ b/src/expand/proc_macro.hpp
@@ -8,8 +8,8 @@
#pragma once
#include <parse/tokenstream.hpp>
-extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& name, const ::AST::Struct& i);
-extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& name, const ::AST::Enum& i);
-extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const ::std::string& name, const ::AST::Union& i);
-//extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<::std::string>& mac_path, const TokenStream& tt);
+extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& name, const ::AST::Struct& i);
+extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& name, const ::AST::Enum& i);
+extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const ::std::string& name, const ::AST::Union& i);
+//extern ::std::unique_ptr<TokenStream> ProcMacro_Invoke(const Span& sp, const ::AST::Crate& crate, const ::std::vector<RcString>& mac_path, const TokenStream& tt);
diff --git a/src/expand/rustc_diagnostics.cpp b/src/expand/rustc_diagnostics.cpp
index 0e95bb7c..b36bf586 100644
--- a/src/expand/rustc_diagnostics.cpp
+++ b/src/expand/rustc_diagnostics.cpp
@@ -13,7 +13,7 @@
class CExpanderRegisterDiagnostic:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
return box$( TTStreamO(sp, TokenTree()) );
}
@@ -21,7 +21,7 @@ class CExpanderRegisterDiagnostic:
class CExpanderDiagnosticUsed:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
return box$( TTStreamO(sp, TokenTree()) );
}
@@ -29,10 +29,8 @@ class CExpanderDiagnosticUsed:
class CExpanderBuildDiagnosticArray:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
- if( ident != "" )
- ERROR(sp, E0000, "__build_diagnostic_array! doesn't take an ident");
auto lex = TTStream(sp, tt);
Token tok;
@@ -41,7 +39,7 @@ class CExpanderBuildDiagnosticArray:
//auto crate_name = mv$(tok.str());
GET_CHECK_TOK(tok, lex, TOK_COMMA);
GET_CHECK_TOK(tok, lex, TOK_IDENT);
- auto item_name = mv$(tok.str());
+ auto item_name = tok.istr();
GET_CHECK_TOK(tok, lex, TOK_EOF);
::std::vector<TokenTree> toks;
@@ -51,9 +49,9 @@ class CExpanderBuildDiagnosticArray:
toks.push_back( TOK_COLON );
toks.push_back( TOK_SQUARE_OPEN );
toks.push_back( TOK_PAREN_OPEN );
- toks.push_back( TOK_AMP ); toks.push_back( Token(TOK_LIFETIME, "static") ); toks.push_back( Token(TOK_IDENT, "str") );
+ toks.push_back( TOK_AMP ); toks.push_back( Token(TOK_LIFETIME, RcString::new_interned("static")) ); toks.push_back( Token(TOK_IDENT, RcString::new_interned("str")) );
toks.push_back( TOK_COMMA );
- toks.push_back( TOK_AMP ); toks.push_back( Token(TOK_LIFETIME, "static") ); toks.push_back( Token(TOK_IDENT, "str") );
+ toks.push_back( TOK_AMP ); toks.push_back( Token(TOK_LIFETIME, RcString::new_interned("static")) ); toks.push_back( Token(TOK_IDENT, RcString::new_interned("str")) );
toks.push_back( TOK_PAREN_CLOSE );
toks.push_back( TOK_SEMICOLON );
toks.push_back( Token(static_cast<uint64_t>(0), CORETYPE_UINT) );
diff --git a/src/expand/stringify.cpp b/src/expand/stringify.cpp
index f552ffd4..561177ef 100644
--- a/src/expand/stringify.cpp
+++ b/src/expand/stringify.cpp
@@ -12,7 +12,7 @@
class CExpander:
public ExpandProcMacro
{
- ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const ::std::string& ident, const TokenTree& tt, AST::Module& mod) override
+ ::std::unique_ptr<TokenStream> expand(const Span& sp, const AST::Crate& crate, const TokenTree& tt, AST::Module& mod) override
{
Token tok;
::std::string rv;
diff --git a/src/expand/test.cpp b/src/expand/test.cpp
index 9497c692..ac536228 100644
--- a/src/expand/test.cpp
+++ b/src/expand/test.cpp
@@ -25,7 +25,7 @@ class CTestHandler:
for(const auto& node : path.nodes())
{
td.name += "::";
- td.name += node.name();
+ td.name += node.name().c_str();
}
td.path = ::AST::Path(path);
diff --git a/src/expand/test_harness.cpp b/src/expand/test_harness.cpp
index f720cac7..36b60632 100644
--- a/src/expand/test_harness.cpp
+++ b/src/expand/test_harness.cpp
@@ -89,10 +89,10 @@ void Expand_TestHarness(::AST::Crate& crate)
auto desc_expr = NEWNODE(_StructLiteral, ::AST::Path("test", { ::AST::PathNode("TestDesc")}), nullptr, mv$(desc_vals));
::AST::ExprNode_StructLiteral::t_values descandfn_vals;
- descandfn_vals.push_back({ {}, ::std::string("desc"), mv$(desc_expr) });
+ descandfn_vals.push_back({ {}, RcString::new_interned("desc"), mv$(desc_expr) });
auto test_type_var_name = test.is_benchmark ? "StaticBenchFn" : "StaticTestFn";
- descandfn_vals.push_back({ {}, ::std::string("testfn"), NEWNODE(_CallPath,
+ descandfn_vals.push_back({ {}, RcString::new_interned("testfn"), NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode(test_type_var_name) }),
::make_vec1( NEWNODE(_NamedValue, AST::Path(test.path)) )
) });
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-02 12:27:40 +0000