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.cpp414
1 files changed, 207 insertions, 207 deletions
diff --git a/src/expand/derive.cpp b/src/expand/derive.cpp
index f6021a7d..46457784 100644
--- a/src/expand/derive.cpp
+++ b/src/expand/derive.cpp
@@ -66,16 +66,16 @@ struct Deriver
{
virtual AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const = 0;
virtual AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const = 0;
-
-
+
+
AST::GenericParams get_params_with_bounds(const Span& sp, const AST::GenericParams& p, const AST::Path& trait_path, ::std::vector<TypeRef> additional_bounded_types) const
{
AST::GenericParams params = p.clone();
-
+
// TODO: Get bounds based on generic (or similar) types used within the type.
// - How would this code (that runs before resolve) know what's a generic and what's a local type?
// - Searches within the type for a Path that starts with that param.
-
+
unsigned int i = 0;
for(const auto& arg : params.ty_params())
{
@@ -84,7 +84,7 @@ struct Deriver
}) );
i ++;
}
-
+
// For each field type
// - Locate used generic parameters in the type (and sub-types that directly use said parameter)
for(auto& ty : additional_bounded_types)
@@ -93,11 +93,11 @@ struct Deriver
mv$(ty), {}, trait_path
}) );
}
-
+
return params;
}
-
-
+
+
::std::vector<TypeRef> get_field_bounds(const AST::Struct& str) const
{
::std::vector<TypeRef> ret;
@@ -140,10 +140,10 @@ struct Deriver
)
)
}
-
+
return ret;
}
-
+
void add_field_bound_from_ty(const AST::GenericParams& params, ::std::vector<TypeRef>& out_list, const TypeRef& ty) const
{
struct H {
@@ -264,14 +264,14 @@ 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
{
const AST::Path debug_trait = AST::Path(core_name, { AST::PathNode("fmt", {}), AST::PathNode("Debug", {}) });
TypeRef f_type(TypeRef::TagReference(), sp, true,
TypeRef(sp, AST::Path(core_name, {AST::PathNode("fmt",{}), AST::PathNode("Formatter", {})}))
);
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -283,19 +283,19 @@ class Deriver_Debug:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, debug_trait, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, debug_trait), type.clone() ) );
rv.add_function(false, false, "fmt", mv$(fcn));
return mv$(rv);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
const ::std::string& name = type.path().nodes().back().name();
-
+
// Generate code for Debug
AST::ExprNodeP node;
TU_MATCH(AST::StructData, (str.m_data), (e),
@@ -345,20 +345,20 @@ public:
node = NEWNODE(CallMethod, mv$(node), AST::PathNode("finish",{}), {});
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), mv$(node));
}
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back() = base_path.nodes().back().name();
-
+
::std::vector< AST::ExprNode_Match_Arm> arms;
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(CallMethod,
@@ -372,34 +372,34 @@ public:
// TODO: Complete this.
::std::vector<AST::Pattern> pats_a;
//::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
//nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
//code = NEWNODE(Block, mv$(nodes));
code = NEWNODE(CallMethod,
NEWNODE(NamedValue, AST::Path("f")),
AST::PathNode("write_str",{}),
vec$( NEWNODE(String, v.m_name + "(...)") )
);
-
+
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
),
(Struct,
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
//::std::vector<AST::ExprNodeP> nodes;
-
+
for( const auto& fld : e.m_fields )
{
auto name_a = FMT("a" << fld.m_name);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
//nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
//code = NEWNODE(Block, mv$(nodes) );
code = NEWNODE(CallMethod,
NEWNODE(NamedValue, AST::Path("f")),
@@ -409,10 +409,10 @@ public:
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_a)) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -423,7 +423,7 @@ public:
NEWNODE(NamedValue, AST::Path("self")),
mv$(arms)
);
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(enm), mv$(node));
}
} g_derive_debug;
@@ -434,7 +434,7 @@ class Deriver_PartialEq:
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
{
const AST::Path trait_path(core_name, { AST::PathNode("cmp", {}), AST::PathNode("PartialEq", {}) });
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -446,9 +446,9 @@ class Deriver_PartialEq:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "eq", mv$(fcn));
return mv$(rv);
@@ -465,7 +465,7 @@ public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
for( const auto& fld : e.ents )
@@ -488,22 +488,22 @@ public:
)
)
nodes.push_back( NEWNODE(Bool, true) );
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
AST::Pattern pat_b;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(Bool, true);
@@ -514,7 +514,7 @@ public:
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::Pattern> pats_b;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
@@ -526,7 +526,7 @@ public:
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( NEWNODE(Bool, true) );
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
pat_b = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_b));
@@ -536,7 +536,7 @@ public:
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_b;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( const auto& fld : e.m_fields )
{
auto name_a = FMT("a" << fld.m_name);
@@ -548,14 +548,14 @@ public:
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( NEWNODE(Bool, true) );
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
pat_b = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_b), true);
code = NEWNODE(Block, mv$(nodes));
)
)
-
+
::std::vector< AST::Pattern> pats;
{
::std::vector< AST::Pattern> tuple_pats;
@@ -563,14 +563,14 @@ public:
tuple_pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_b)) );
pats.push_back( AST::Pattern(AST::Pattern::TagTuple(), mv$(tuple_pats)) );
}
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
mv$(code)
));
}
-
+
// Default arm
{
arms.push_back(AST::ExprNode_Match_Arm(
@@ -593,7 +593,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, {}) });
@@ -602,15 +602,15 @@ class Deriver_PartialOrd:
{
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
{
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", {}) });
-
+
AST::Path path_option_ordering(core_name, { AST::PathNode("option", {}), AST::PathNode("Option", {}) });
path_option_ordering.nodes().back().args().m_types.push_back( TypeRef(sp, path_ordering) );
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -622,14 +622,14 @@ class Deriver_PartialOrd:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "partial_cmp", mv$(fcn));
return mv$(rv);
}
-
+
AST::ExprNodeP make_compare_and_ret(Span sp, const ::std::string& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
{
return NEWNODE(Match,
@@ -670,7 +670,7 @@ public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
for( const auto& fld : e.ents )
@@ -693,22 +693,22 @@ public:
)
)
nodes.push_back( this->make_ret_equal(core_name) );
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
AST::Pattern pat_b;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = this->make_ret_equal(core_name);
@@ -719,20 +719,20 @@ public:
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::Pattern> pats_b;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
auto name_b = FMT("b" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
pats_b.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_b, ::AST::PatternBinding::Type::REF) );
-
+
nodes.push_back(this->make_compare_and_ret( sp, core_name,
NEWNODE(NamedValue, AST::Path(name_a)),
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( this->make_ret_equal(core_name) );
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
pat_b = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_b));
@@ -742,27 +742,27 @@ public:
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
::std::vector< ::std::pair<std::string, 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);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
pats_b.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_b, ::AST::PatternBinding::Type::REF)) );
-
+
nodes.push_back(this->make_compare_and_ret( sp, core_name,
NEWNODE(NamedValue, AST::Path(name_a)),
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( this->make_ret_equal(core_name) );
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
pat_b = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_b), true);
code = NEWNODE(Block, mv$(nodes));
)
)
-
+
::std::vector< AST::Pattern> pats;
{
::std::vector< AST::Pattern> tuple_pats;
@@ -770,25 +770,25 @@ public:
tuple_pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_b)) );
pats.push_back( AST::Pattern(AST::Pattern::TagTuple(), mv$(tuple_pats)) );
}
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
mv$(code)
));
}
-
+
for(unsigned int a = 0; a < enm.variants().size(); a ++ )
{
for(unsigned int b = 0; b < enm.variants().size(); b ++ )
{
if( a == b )
continue ;
-
+
struct H {
static ::AST::Pattern get_pat_nc(const AST::Path& base_path, const AST::EnumVariant& v) {
AST::Path var_path = base_path + v.m_name;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
return AST::Pattern(AST::Pattern::TagValue(), AST::Pattern::Value::make_Named(var_path));
@@ -805,7 +805,7 @@ public:
};
::AST::Pattern pat_a = H::get_pat_nc(base_path, enm.variants()[a]);
::AST::Pattern pat_b = H::get_pat_nc(base_path, enm.variants()[b]);
-
+
::std::vector< AST::Pattern> pats;
{
::std::vector< AST::Pattern> tuple_pats;
@@ -813,13 +813,13 @@ public:
tuple_pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_b)) );
pats.push_back( AST::Pattern(AST::Pattern::TagTuple(), mv$(tuple_pats)) );
}
-
+
auto code = NEWNODE(CallPath, this->get_path(core_name, "option", "Option", "Some"),
::make_vec1(
NEWNODE(NamedValue, this->get_path(core_name, "cmp", "Ordering", (a < b ? "Less" : "Greater")))
)
);
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -844,11 +844,11 @@ class Deriver_Eq:
AST::Path get_trait_path(const ::std::string& 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
{
const AST::Path trait_path = this->get_trait_path(core_name);
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -859,9 +859,9 @@ class Deriver_Eq:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "assert_receiver_is_total_eq", mv$(fcn));
return mv$(rv);
@@ -875,13 +875,13 @@ class Deriver_Eq:
AST::ExprNodeP field(const ::std::string& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
const AST::Path assert_method_path = this->get_trait_path(core_name) + "assert_receiver_is_total_eq";
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
for( const auto& fld : e.ents )
@@ -896,10 +896,10 @@ public:
}
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
const AST::Path assert_method_path = this->get_trait_path(core_name) + "assert_receiver_is_total_eq";
@@ -907,12 +907,12 @@ public:
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(Block);
@@ -921,36 +921,36 @@ public:
(Tuple,
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
code = NEWNODE(Block, mv$(nodes));
),
(Struct,
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( const auto& fld : e.m_fields )
{
auto name_a = FMT("a" << fld.m_name);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
nodes.push_back( this->assert_is_eq(assert_method_path, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
code = NEWNODE(Block, mv$(nodes));
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_a)) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -968,7 +968,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, {}) });
@@ -977,12 +977,12 @@ class Deriver_Ord:
{
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
{
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", {}) });
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -994,14 +994,14 @@ class Deriver_Ord:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "cmp", mv$(fcn));
return mv$(rv);
}
-
+
AST::ExprNodeP make_compare_and_ret(Span sp, const ::std::string& core_name, AST::ExprNodeP v1, AST::ExprNodeP v2) const
{
return NEWNODE(Match,
@@ -1034,7 +1034,7 @@ public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
for( const auto& fld : e.ents )
@@ -1057,22 +1057,22 @@ public:
)
)
nodes.push_back( this->make_ret_equal(core_name) );
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
AST::Pattern pat_b;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = this->make_ret_equal(core_name);
@@ -1083,20 +1083,20 @@ public:
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::Pattern> pats_b;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
auto name_b = FMT("b" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
pats_b.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_b, ::AST::PatternBinding::Type::REF) );
-
+
nodes.push_back(this->make_compare_and_ret( sp, core_name,
NEWNODE(NamedValue, AST::Path(name_a)),
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( this->make_ret_equal(core_name) );
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
pat_b = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_b));
@@ -1106,27 +1106,27 @@ public:
::std::vector< ::std::pair<std::string, AST::Pattern> > pats_a;
::std::vector< ::std::pair<std::string, 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);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
pats_b.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_b, ::AST::PatternBinding::Type::REF)) );
-
+
nodes.push_back(this->make_compare_and_ret( sp, core_name,
NEWNODE(NamedValue, AST::Path(name_a)),
NEWNODE(NamedValue, AST::Path(name_b))
));
}
-
+
nodes.push_back( this->make_ret_equal(core_name) );
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
pat_b = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_b), true);
code = NEWNODE(Block, mv$(nodes));
)
)
-
+
::std::vector< AST::Pattern> pats;
{
::std::vector< AST::Pattern> tuple_pats;
@@ -1134,25 +1134,25 @@ public:
tuple_pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_b)) );
pats.push_back( AST::Pattern(AST::Pattern::TagTuple(), mv$(tuple_pats)) );
}
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
mv$(code)
));
}
-
+
for(unsigned int a = 0; a < enm.variants().size(); a ++ )
{
for(unsigned int b = 0; b < enm.variants().size(); b ++ )
{
if( a == b )
continue ;
-
+
struct H {
static ::AST::Pattern get_pat_nc(const AST::Path& base_path, const AST::EnumVariant& v) {
AST::Path var_path = base_path + v.m_name;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
return AST::Pattern(AST::Pattern::TagValue(), AST::Pattern::Value::make_Named(var_path));
@@ -1169,7 +1169,7 @@ public:
};
::AST::Pattern pat_a = H::get_pat_nc(base_path, enm.variants()[a]);
::AST::Pattern pat_b = H::get_pat_nc(base_path, enm.variants()[b]);
-
+
::std::vector< AST::Pattern> pats;
{
::std::vector< AST::Pattern> tuple_pats;
@@ -1177,9 +1177,9 @@ public:
tuple_pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_b)) );
pats.push_back( AST::Pattern(AST::Pattern::TagTuple(), mv$(tuple_pats)) );
}
-
+
auto code = NEWNODE(NamedValue, this->get_path(core_name, "cmp", "Ordering", (a < b ? "Less" : "Greater")));
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -1207,11 +1207,11 @@ class Deriver_Clone:
AST::Path get_method_path(const ::std::string& 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
{
const AST::Path trait_path = this->get_trait_path(core_name);
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -1222,9 +1222,9 @@ class Deriver_Clone:
)
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "clone", mv$(fcn));
return mv$(rv);
@@ -1244,13 +1244,13 @@ class Deriver_Clone:
AST::ExprNodeP field(const ::std::string& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
const AST::Path& ty_path = type.m_data.as_Path().path;
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
::std::vector< ::std::pair< ::std::string, AST::ExprNodeP> > vals;
@@ -1276,21 +1276,21 @@ public:
}
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(const auto& v : enm.variants())
{
AST::ExprNodeP code;
AST::Pattern pat_a;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(NamedValue, base_path + v.m_name);
@@ -1299,36 +1299,36 @@ public:
(Tuple,
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->clone_val_direct(core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
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<std::string, AST::ExprNodeP> > vals;
-
+
for( const auto& fld : e.m_fields )
{
auto name_a = FMT("a" << fld.m_name);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
vals.push_back( ::std::make_pair( fld.m_name, this->clone_val_direct(core_name, NEWNODE(NamedValue, AST::Path(name_a))) ) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
code = NEWNODE(StructLiteral, base_path + v.m_name, nullptr, mv$(vals));
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_a)) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -1349,23 +1349,23 @@ class Deriver_Copy:
AST::Path get_trait_path(const ::std::string& 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
{
const AST::Path trait_path = this->get_trait_path(core_name);
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
return mv$(rv);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), nullptr);
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(enm), nullptr);
@@ -1381,11 +1381,11 @@ class Deriver_Default:
AST::Path get_method_path(const ::std::string& 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
{
const AST::Path trait_path = this->get_trait_path(core_name);
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -1394,9 +1394,9 @@ class Deriver_Default:
{}
);
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "default", mv$(fcn));
return mv$(rv);
@@ -1407,13 +1407,13 @@ class Deriver_Default:
{}
);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
const AST::Path& ty_path = type.m_data.as_Path().path;
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
::std::vector< ::std::pair< ::std::string, AST::ExprNodeP> > vals;
@@ -1439,10 +1439,10 @@ public:
}
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
ERROR(sp, E0000, "Default cannot be derived for enums");
@@ -1461,11 +1461,11 @@ class Deriver_Hash:
AST::Path get_method_path(const ::std::string& 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
{
const AST::Path trait_path = this->get_trait_path(core_name);
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -1483,9 +1483,9 @@ class Deriver_Hash:
this->get_trait_path_Hasher(core_name)
}) );
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "hash", mv$(fcn));
return mv$(rv);
@@ -1502,12 +1502,12 @@ class Deriver_Hash:
AST::ExprNodeP field(const ::std::string& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
{
::std::vector<AST::ExprNodeP> nodes;
-
+
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
for( const auto& fld : e.ents )
@@ -1522,24 +1522,24 @@ public:
}
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), NEWNODE(Block, mv$(nodes)));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(unsigned int var_idx = 0; var_idx < enm.variants().size(); var_idx ++)
{
const auto& v = enm.variants()[var_idx];
AST::ExprNodeP code;
AST::Pattern pat_a;
-
+
auto var_idx_hash = this->hash_val_ref( core_name, NEWNODE(Integer, var_idx, CORETYPE_UINT) );
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = mv$(var_idx_hash);
@@ -1549,14 +1549,14 @@ public:
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::ExprNodeP> nodes;
nodes.push_back( mv$(var_idx_hash) );
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
pats_a.push_back( ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF) );
nodes.push_back( this->hash_val_direct(core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagNamedTuple(), base_path + v.m_name, mv$(pats_a));
code = NEWNODE(Block, mv$(nodes));
),
@@ -1564,22 +1564,22 @@ public:
::std::vector< ::std::pair<std::string, 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);
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), name_a, ::AST::PatternBinding::Type::REF)) );
nodes.push_back( this->hash_val_direct(core_name, NEWNODE(NamedValue, AST::Path(name_a))) );
}
-
+
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
code = NEWNODE(Block, mv$(nodes));
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_a)) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -1607,15 +1607,15 @@ class Deriver_RustcEncodable:
AST::Path get_method_path() const {
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
{
const AST::Path trait_path = this->get_trait_path();
-
+
AST::Path result_path = AST::Path(core_name, { AST::PathNode("result", {}), AST::PathNode("Result", {}) });
result_path.nodes()[1].args().m_types.push_back( TypeRef(TypeRef::TagUnit(), sp) );
result_path.nodes()[1].args().m_types.push_back(TypeRef( sp, AST::Path(AST::Path::TagUfcs(), TypeRef(sp, "S", 0x100|0), this->get_trait_path_Encoder(), { AST::PathNode("Error",{}) }) ));
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -1633,9 +1633,9 @@ class Deriver_RustcEncodable:
this->get_trait_path_Encoder()
}) );
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "encode", mv$(fcn));
return mv$(rv);
@@ -1649,7 +1649,7 @@ class Deriver_RustcEncodable:
AST::ExprNodeP field(const ::std::string& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
-
+
AST::ExprNodeP enc_closure(Span sp, AST::ExprNodeP code) const {
return NEWNODE(Closure,
vec$( ::std::make_pair( AST::Pattern(AST::Pattern::TagBind(), "s"), ::TypeRef(sp) ) ), ::TypeRef(sp),
@@ -1659,12 +1659,12 @@ class Deriver_RustcEncodable:
AST::ExprNodeP get_val_ok(const ::std::string& core_name) const {
return NEWNODE(CallPath, AST::Path(core_name, {AST::PathNode("result",{}), AST::PathNode("Result",{}), AST::PathNode("Ok",{})}), vec$( NEWNODE(Tuple, {})) );
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, 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::vector<AST::ExprNodeP> nodes;
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
@@ -1691,7 +1691,7 @@ public:
nodes.push_back( this->get_val_ok(core_name) );
auto closure = this->enc_closure( sp, NEWNODE(Block, mv$(nodes)) );
-
+
::AST::ExprNodeP node;
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
@@ -1707,22 +1707,22 @@ public:
);
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), mv$(node));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
for(unsigned int var_idx = 0; var_idx < enm.variants().size(); var_idx ++)
{
const auto& v = enm.variants()[var_idx];
AST::ExprNodeP code;
AST::Pattern pat_a;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_variant",
@@ -1739,7 +1739,7 @@ public:
(Tuple,
::std::vector<AST::Pattern> pats_a;
::std::vector<AST::ExprNodeP> nodes;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
@@ -1753,7 +1753,7 @@ public:
) );
}
nodes.push_back( this->get_val_ok(core_name) );
-
+
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_variant",
vec$(
NEWNODE(NamedValue, AST::Path("s")),
@@ -1768,13 +1768,13 @@ public:
(Struct,
::std::vector< ::std::pair<std::string, 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) );
pats_a.push_back( ::std::make_pair(fld.m_name, ::AST::Pattern(::AST::Pattern::TagBind(), 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")),
@@ -1786,7 +1786,7 @@ public:
idx ++;
}
nodes.push_back( this->get_val_ok(core_name) );
-
+
pat_a = AST::Pattern(AST::Pattern::TagStruct(), base_path + v.m_name, mv$(pats_a), true);
code = NEWNODE(CallPath, this->get_trait_path_Encoder() + "emit_enum_struct_variant",
vec$(
@@ -1799,19 +1799,19 @@ public:
);
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagReference(), false, mv$(pat_a)) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
mv$(code)
));
}
-
+
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();
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)) )
@@ -1834,15 +1834,15 @@ class Deriver_RustcDecodable:
AST::Path get_method_path() const {
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
{
const AST::Path trait_path = this->get_trait_path();
-
+
AST::Path result_path = AST::Path(core_name, { AST::PathNode("result", {}), AST::PathNode("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",{}) })) );
-
+
AST::Function fcn(
sp,
AST::GenericParams(),
@@ -1860,9 +1860,9 @@ class Deriver_RustcDecodable:
this->get_trait_path_Decoder()
}) );
fcn.set_code( NEWNODE(Block, vec$(mv$(node))) );
-
+
AST::GenericParams params = get_params_with_bounds(sp, p, trait_path, mv$(types_to_bound));
-
+
AST::Impl rv( AST::ImplDef( sp, AST::MetaItems(), mv$(params), make_spanned(sp, trait_path), type.clone() ) );
rv.add_function(false, false, "decode", mv$(fcn));
return mv$(rv);
@@ -1873,7 +1873,7 @@ class Deriver_RustcDecodable:
AST::ExprNodeP field(const ::std::string& name) const {
return NEWNODE(Field, NEWNODE(NamedValue, AST::Path("self")), name);
}
-
+
AST::ExprNodeP dec_closure(Span sp, AST::ExprNodeP code) const {
return NEWNODE(Closure,
vec$( ::std::make_pair( AST::Pattern(AST::Pattern::TagBind(), "d"), ::TypeRef(sp) ) ), ::TypeRef(sp),
@@ -1895,13 +1895,13 @@ class Deriver_RustcDecodable:
AST::ExprNodeP get_val_ok_unit(const ::std::string& core_name) const {
return get_val_ok(core_name, NEWNODE(Tuple, {}));
}
-
+
public:
AST::Impl handle_item(Span sp, const ::std::string& core_name, 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();
-
+
AST::ExprNodeP node_v;
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
@@ -1931,9 +1931,9 @@ public:
)
auto closure = this->dec_closure( sp, this->get_val_ok(core_name, mv$(node_v)) );
-
+
auto args = vec$( NEWNODE(NamedValue, AST::Path("d")), NEWNODE(String, struct_name), AST::ExprNodeP(), mv$(closure) );
-
+
::AST::ExprNodeP node;
TU_MATCH(AST::StructData, (str.m_data), (e),
(Struct,
@@ -1947,32 +1947,32 @@ public:
node = NEWNODE(CallPath, this->get_trait_path_Decoder() + "read_tuple_struct", mv$(args) );
)
)
-
+
return this->make_ret(sp, core_name, p, type, this->get_field_bounds(str), mv$(node));
}
-
+
AST::Impl handle_item(Span sp, const ::std::string& core_name, const AST::GenericParams& p, const TypeRef& type, const AST::Enum& enm) const override
{
AST::Path base_path = type.m_data.as_Path().path;
base_path.nodes().back().args() = ::AST::PathParams();
::std::vector<AST::ExprNode_Match_Arm> arms;
-
+
// 1. Variant names
::std::vector< AST::ExprNodeP> var_name_strs;
-
+
// 2. Decoding arms
for(unsigned int var_idx = 0; var_idx < enm.variants().size(); var_idx ++)
{
const auto& v = enm.variants()[var_idx];
AST::ExprNodeP code;
-
+
TU_MATCH(::AST::EnumVariantData, (v.m_data), (e),
(Value,
code = NEWNODE(NamedValue, base_path + v.m_name);
),
(Tuple,
::std::vector<AST::ExprNodeP> args;
-
+
for( unsigned int idx = 0; idx < e.m_sub_types.size(); idx ++ )
{
auto name_a = FMT("a" << idx);
@@ -1988,12 +1988,12 @@ public:
),
(Struct,
::std::vector< ::std::pair< ::std::string, AST::ExprNodeP > > vals;
-
+
unsigned int idx = 0;
for( const auto& fld : e.m_fields )
{
auto name_a = FMT("a" << fld.m_name);
-
+
vals.push_back(::std::make_pair(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")),
@@ -2004,14 +2004,14 @@ public:
) )));
idx ++;
}
-
+
code = NEWNODE(StructLiteral, base_path + v.m_name, nullptr, mv$(vals) );
)
)
-
+
::std::vector< AST::Pattern> pats;
pats.push_back( AST::Pattern(AST::Pattern::TagValue(), AST::Pattern::Value::make_Integer({CORETYPE_UINT, var_idx})) );
-
+
arms.push_back(AST::ExprNode_Match_Arm(
mv$(pats),
nullptr,
@@ -2019,7 +2019,7 @@ public:
));
var_name_strs.push_back( NEWNODE(String, v.m_name) );
}
-
+
// Default arm
{
arms.push_back(AST::ExprNode_Match_Arm(
@@ -2028,7 +2028,7 @@ public:
this->get_val_err_str(core_name, "enum value unknown")
));
}
-
+
auto node_match = NEWNODE(Match, NEWNODE(NamedValue, AST::Path("idx")), mv$(arms));
auto node_var_closure = NEWNODE(Closure,
vec$(
@@ -2040,7 +2040,7 @@ public:
false
);
const ::std::string& enum_name = type.m_data.as_Path().path.nodes().back().name();
-
+
auto node_rev = NEWNODE(CallPath, this->get_trait_path_Decoder() + "read_enum_variant",
vec$(
NEWNODE(NamedValue, AST::Path("d")),
@@ -2048,7 +2048,7 @@ public:
mv$( node_var_closure )
)
);
-
+
auto node = NEWNODE(CallPath, this->get_trait_path_Decoder() + "read_enum",
vec$( NEWNODE(NamedValue, AST::Path("d")), NEWNODE(String, enum_name), this->dec_closure(sp, mv$(node_rev)) )
);
@@ -2096,17 +2096,17 @@ static void derive_item(const Span& sp, const AST::Crate& crate, AST::Module& mo
//ERROR(sp, E0000, "#[derive()] requires a list of known traits to derive");
return ;
}
-
+
DEBUG("path = " << path);
bool fail = false;
-
+
const auto& params = item.params();
TypeRef type(sp, path);
auto& types_args = type.path().nodes().back().args();
for( const auto& param : params.ty_params() ) {
types_args.m_types.push_back( TypeRef(TypeRef::TagArg(), sp, param.name()) );
}
-
+
::std::vector< ::std::string> missing_handlers;
for( const auto& trait : attr.items() )
{
@@ -2118,10 +2118,10 @@ static void derive_item(const Span& sp, const AST::Crate& crate, AST::Module& mo
fail = true;
continue ;
}
-
+
mod.add_item(false, "", dp->handle_item(sp, (crate.m_load_std == ::AST::Crate::LOAD_NONE ? "" : "core"), params, type, item), {} );
}
-
+
if( fail ) {
ERROR(sp, E0000, "Failed to apply #[derive] - Missing handlers for " << missing_handlers);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-02 20:52:03 +0000