No more tears!

No more DOS line endings or trailing whitespace either

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);
     }