summaryrefslogtreecommitdiff
path: root/src/expand/derive.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/expand/derive.cpp')
-rw-r--r--src/expand/derive.cpp276
1 files changed, 142 insertions, 134 deletions
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);
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-01 22:08:53 +0000