Trans - Efficiency cleanups

5 files changed, 71 insertions, 67 deletions

diff --git a/src/trans/enumerate.cpp b/src/trans/enumerate.cpp
index 1750e730..c6433b18 100644
--- a/src/trans/enumerate.cpp
+++ b/src/trans/enumerate.cpp
@@ -25,6 +25,7 @@ namespace {
 
         // Queue of items to enumerate
         ::std::deque<TransList_Function*>  fcn_queue;
+        ::std::vector<TransList_Function*> fcns_to_type_visit;
 
         EnumState(const ::HIR::Crate& crate):
             crate(crate)
@@ -34,6 +35,7 @@ namespace {
         {
             if(auto* e = rv.add_function(mv$(p)))
             {
+                fcns_to_type_visit.push_back(e);
                 e->ptr = &fcn;
                 e->pp = mv$(pp);
                 fcn_queue.push_back(e);
@@ -346,26 +348,30 @@ void Trans_Enumerate_Types(EnumState& state)
     bool constructors_added;
     do
     {
-        for(const auto& ent : state.rv.m_functions)
+        // Visit all functions that haven't been type-visited yet
+        for(unsigned int i = 0; i < state.fcns_to_type_visit.size(); i++)
         {
-            TRACE_FUNCTION_F("Enumerate fn " << ent.first);
-            assert(ent.second->ptr);
-            const auto& fcn = *ent.second->ptr;
-            const auto& pp = ent.second->pp;
+            auto p = state.fcns_to_type_visit[i];
+            TRACE_FUNCTION_F("Function " << ::std::find_if(state.rv.m_functions.begin(), state.rv.m_functions.end(), [&](const auto&x){ return x.second.get() == p; })->first);
+            assert(p->ptr);
+            const auto& fcn = *p->ptr;
+            const auto& pp = p->pp;
 
-            tv.visit_type( pp.monomorph(state.crate, fcn.m_return) );
+            tv.visit_type( pp.monomorph(tv.m_resolve, fcn.m_return) );
             for(const auto& arg : fcn.m_args)
-                tv.visit_type( pp.monomorph(state.crate, arg.second) );
+                tv.visit_type( pp.monomorph(tv.m_resolve, arg.second) );
 
             if( fcn.m_code.m_mir )
             {
                 const auto& mir = *fcn.m_code.m_mir;
                 for(const auto& ty : mir.named_variables)
-                    tv.visit_type(pp.monomorph(state.crate, ty));
+                    tv.visit_type(pp.monomorph(tv.m_resolve, ty));
                 for(const auto& ty : mir.temporaries)
-                    tv.visit_type(pp.monomorph(state.crate, ty));
+                    tv.visit_type(pp.monomorph(tv.m_resolve, ty));
             }
         }
+        state.fcns_to_type_visit.clear();
+        // TODO: Similarly restrict revisiting of statics.
         for(const auto& ent : state.rv.m_statics)
         {
             TRACE_FUNCTION_F("Enumerate static " << ent.first);
@@ -373,7 +379,7 @@ void Trans_Enumerate_Types(EnumState& state)
             const auto& stat = *ent.second->ptr;
             const auto& pp = ent.second->pp;
 
-            tv.visit_type( pp.monomorph(state.crate, stat.m_type) );
+            tv.visit_type( pp.monomorph(tv.m_resolve, stat.m_type) );
         }
 
         constructors_added = false;
diff --git a/src/trans/monomorphise.cpp b/src/trans/monomorphise.cpp
index 03623855..dd30dc7a 100644
--- a/src/trans/monomorphise.cpp
+++ b/src/trans/monomorphise.cpp
@@ -10,7 +10,7 @@
 #include <hir/hir.hpp>
 
 namespace {
-    ::MIR::LValue monomorph_LValue(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::LValue& tpl)
+    ::MIR::LValue monomorph_LValue(const ::StaticTraitResolve& resolve, const Trans_Params& params, const ::MIR::LValue& tpl)
     {
         TU_MATCHA( (tpl), (e),
         (Variable,  return e; ),
@@ -18,45 +18,45 @@ namespace {
         (Argument,  return e; ),
         (Return, return e; ),
         (Static,
-            return params.monomorph(crate, e);
+            return params.monomorph(resolve, e);
             ),
         (Field,
             return ::MIR::LValue::make_Field({
-                box$(monomorph_LValue(crate, params, *e.val)),
+                box$(monomorph_LValue(resolve, params, *e.val)),
                 e.field_index
                 });
             ),
         (Deref,
             return ::MIR::LValue::make_Deref({
-                box$(monomorph_LValue(crate, params, *e.val))
+                box$(monomorph_LValue(resolve, params, *e.val))
                 });
             ),
         (Index,
             return ::MIR::LValue::make_Index({
-                box$(monomorph_LValue(crate, params, *e.val)),
-                box$(monomorph_LValue(crate, params, *e.idx))
+                box$(monomorph_LValue(resolve, params, *e.val)),
+                box$(monomorph_LValue(resolve, params, *e.idx))
                 });
             ),
         (Downcast,
             return ::MIR::LValue::make_Downcast({
-                box$(monomorph_LValue(crate, params, *e.val)),
+                box$(monomorph_LValue(resolve, params, *e.val)),
                 e.variant_index
                 });
             )
         )
         throw "";
     }
-    ::std::vector<::MIR::LValue> monomorph_LValue_list(const ::HIR::Crate& crate, const Trans_Params& params, const ::std::vector<::MIR::LValue>& tpl)
+    ::std::vector<::MIR::LValue> monomorph_LValue_list(const ::StaticTraitResolve& resolve, const Trans_Params& params, const ::std::vector<::MIR::LValue>& tpl)
     {
         ::std::vector<::MIR::LValue>    rv;
         rv.reserve( tpl.size() );
         for(const auto& v : tpl)
-            rv.push_back( monomorph_LValue(crate, params, v) );
+            rv.push_back( monomorph_LValue(resolve, params, v) );
         return rv;
     }
 }
 
-::MIR::FunctionPointer Trans_Monomorphise(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl)
+::MIR::FunctionPointer Trans_Monomorphise(const ::StaticTraitResolve& resolve, const Trans_Params& params, const ::MIR::FunctionPointer& tpl)
 {
     static Span sp;
     TRACE_FUNCTION;
@@ -68,13 +68,13 @@ namespace {
     for(const auto& var : tpl->named_variables)
     {
         DEBUG("- var" << output.named_variables.size());
-        output.named_variables.push_back( params.monomorph(crate, var) );
+        output.named_variables.push_back( params.monomorph(resolve, var) );
     }
     output.temporaries.reserve( tpl->temporaries.size() );
     for(const auto& ty : tpl->temporaries)
     {
-        DEBUG("- var" << output.temporaries.size());
-        output.temporaries.push_back( params.monomorph(crate, ty) );
+        DEBUG("- tmp" << output.temporaries.size());
+        output.temporaries.push_back( params.monomorph(resolve, ty) );
     }
 
     // 2. Monomorphise all paths
@@ -94,7 +94,7 @@ namespace {
                 DEBUG("- DROP " << e.slot);
                 statements.push_back( ::MIR::Statement::make_Drop({
                     e.kind,
-                    monomorph_LValue(crate, params, e.slot)
+                    monomorph_LValue(resolve, params, e.slot)
                     }) );
             }
             else
@@ -105,7 +105,7 @@ namespace {
                 ::MIR::RValue   rval;
                 TU_MATCHA( (e.src), (se),
                 (Use,
-                    rval = ::MIR::RValue( monomorph_LValue(crate, params, se) );
+                    rval = ::MIR::RValue( monomorph_LValue(resolve, params, se) );
                     ),
                 (Constant,
                     TU_MATCHA( (se), (ce),
@@ -129,11 +129,11 @@ namespace {
                         ),
                     (Const,
                         rval = ::MIR::Constant::make_Const({
-                            params.monomorph(crate, ce.p)
+                            params.monomorph(resolve, ce.p)
                             });
                         ),
                     (ItemAddr,
-                        auto p = params.monomorph(crate, ce);
+                        auto p = params.monomorph(resolve, ce);
                         // TODO: If this is a pointer to a function on a trait object, replace with the address loaded from the vtable.
                         // - Requires creating a new temporary for the vtable pointer.
                         // - Also requires knowing what the receiver is.
@@ -143,79 +143,79 @@ namespace {
                     ),
                 (SizedArray,
                     rval = ::MIR::RValue::make_SizedArray({
-                        monomorph_LValue(crate, params, se.val),
+                        monomorph_LValue(resolve, params, se.val),
                         se.count
                         });
                     ),
                 (Borrow,
                     rval = ::MIR::RValue::make_Borrow({
                         se.region, se.type,
-                        monomorph_LValue(crate, params, se.val)
+                        monomorph_LValue(resolve, params, se.val)
                         });
                     ),
                 (Cast,
                     rval = ::MIR::RValue::make_Cast({
-                        monomorph_LValue(crate, params, se.val),
-                        params.monomorph(crate, se.type)
+                        monomorph_LValue(resolve, params, se.val),
+                        params.monomorph(resolve, se.type)
                         });
                     ),
                 (BinOp,
                     rval = ::MIR::RValue::make_BinOp({
-                        monomorph_LValue(crate, params, se.val_l),
+                        monomorph_LValue(resolve, params, se.val_l),
                         se.op,
-                        monomorph_LValue(crate, params, se.val_r)
+                        monomorph_LValue(resolve, params, se.val_r)
                         });
                     ),
                 (UniOp,
                     rval = ::MIR::RValue::make_UniOp({
-                        monomorph_LValue(crate, params, se.val),
+                        monomorph_LValue(resolve, params, se.val),
                         se.op
                         });
                     ),
                 (DstMeta,
-                    auto lv = monomorph_LValue(crate, params, se.val);
+                    auto lv = monomorph_LValue(resolve, params, se.val);
                     // TODO: Get the type of this, and if it's an array - replace with the size
                     rval = ::MIR::RValue::make_DstMeta({ mv$(lv) });
                     ),
                 (DstPtr,
-                    rval = ::MIR::RValue::make_DstPtr({ monomorph_LValue(crate, params, se.val) });
+                    rval = ::MIR::RValue::make_DstPtr({ monomorph_LValue(resolve, params, se.val) });
                     ),
                 (MakeDst,
                     rval = ::MIR::RValue::make_MakeDst({
-                        monomorph_LValue(crate, params, se.ptr_val),
-                        monomorph_LValue(crate, params, se.meta_val)
+                        monomorph_LValue(resolve, params, se.ptr_val),
+                        monomorph_LValue(resolve, params, se.meta_val)
                         });
                     ),
                 (Tuple,
                     rval = ::MIR::RValue::make_Tuple({
-                        monomorph_LValue_list(crate, params, se.vals)
+                        monomorph_LValue_list(resolve, params, se.vals)
                         });
                     ),
                 (Array,
                     rval = ::MIR::RValue::make_Array({
-                        monomorph_LValue_list(crate, params, se.vals)
+                        monomorph_LValue_list(resolve, params, se.vals)
                         });
                     ),
                 // Create a new instance of a union (and eventually enum)
                 (Variant,
                     rval = ::MIR::RValue::make_Variant({
-                        params.monomorph(crate, se.path),
+                        params.monomorph(resolve, se.path),
                         se.index,
-                        monomorph_LValue(crate, params, se.val)
+                        monomorph_LValue(resolve, params, se.val)
                         });
                     ),
                 // Create a new instance of a struct (or enum)
                 (Struct,
                     rval = ::MIR::RValue::make_Struct({
-                        params.monomorph(crate, se.path),
+                        params.monomorph(resolve, se.path),
                         se.variant_idx,
-                        monomorph_LValue_list(crate, params, se.vals)
+                        monomorph_LValue_list(resolve, params, se.vals)
                         });
                     )
                 )
 
                 statements.push_back( ::MIR::Statement::make_Assign({
-                    monomorph_LValue(crate, params, e.dst),
+                    monomorph_LValue(resolve, params, e.dst),
                     mv$(rval)
                     }) );
             }
@@ -243,28 +243,28 @@ namespace {
             ),
         (If,
             terminator = ::MIR::Terminator::make_If({
-                monomorph_LValue(crate, params, e.cond),
+                monomorph_LValue(resolve, params, e.cond),
                 e.bb0, e.bb1
                 });
             ),
         (Switch,
             terminator = ::MIR::Terminator::make_Switch({
-                monomorph_LValue(crate, params, e.val),
+                monomorph_LValue(resolve, params, e.val),
                 e.targets
                 });
             ),
         (Call,
             struct H {
-                static ::MIR::CallTarget monomorph_calltarget(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::CallTarget& ct) {
+                static ::MIR::CallTarget monomorph_calltarget(const ::StaticTraitResolve& resolve, const Trans_Params& params, const ::MIR::CallTarget& ct) {
                     TU_MATCHA( (ct), (e),
                     (Value,
-                        return monomorph_LValue(crate, params, e);
+                        return monomorph_LValue(resolve, params, e);
                         ),
                     (Path,
-                        return params.monomorph(crate, e);
+                        return params.monomorph(resolve, e);
                         ),
                     (Intrinsic,
-                        return ::MIR::CallTarget::make_Intrinsic({ e.name, params.monomorph(crate, e.params) });
+                        return ::MIR::CallTarget::make_Intrinsic({ e.name, params.monomorph(resolve, e.params) });
                         )
                     )
                     throw "";
@@ -272,9 +272,9 @@ namespace {
             };
             terminator = ::MIR::Terminator::make_Call({
                 e.ret_block, e.panic_block,
-                monomorph_LValue(crate, params, e.ret_val),
-                H::monomorph_calltarget(crate, params, e.fcn),
-                monomorph_LValue_list(crate, params, e.args)
+                monomorph_LValue(resolve, params, e.ret_val),
+                H::monomorph_calltarget(resolve, params, e.fcn),
+                monomorph_LValue_list(resolve, params, e.args)
                 });
             )
         )
diff --git a/src/trans/monomorphise.hpp b/src/trans/monomorphise.hpp
index 16a5d742..f1ffea2d 100644
--- a/src/trans/monomorphise.hpp
+++ b/src/trans/monomorphise.hpp
@@ -14,4 +14,4 @@ namespace HIR {
     class Crate;
 }
 
-extern ::MIR::FunctionPointer Trans_Monomorphise(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl);
+extern ::MIR::FunctionPointer Trans_Monomorphise(const ::StaticTraitResolve& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl);
diff --git a/src/trans/trans_list.cpp b/src/trans/trans_list.cpp
index f6a14c7e..04e1e9a1 100644
--- a/src/trans/trans_list.cpp
+++ b/src/trans/trans_list.cpp
@@ -43,12 +43,11 @@ t_cb_generic Trans_Params::get_cb() const
 {
     return monomorphise_type_get_cb(sp, &self_type, &pp_impl, &pp_method);
 }
-::HIR::Path Trans_Params::monomorph(const ::HIR::Crate& crate, const ::HIR::Path& p) const
+::HIR::Path Trans_Params::monomorph(const ::StaticTraitResolve& resolve, const ::HIR::Path& p) const
 {
     TRACE_FUNCTION_F(p);
     auto rv = monomorphise_path_with(sp, p, this->get_cb(), false);
 
-    ::StaticTraitResolve    resolve { crate };
     TU_MATCH(::HIR::Path::Data, (rv.m_data), (e2),
     (Generic,
         for(auto& arg : e2.m_params.m_types)
@@ -76,24 +75,22 @@ t_cb_generic Trans_Params::get_cb() const
     return rv;
 }
 
-::HIR::GenericPath Trans_Params::monomorph(const ::HIR::Crate& crate, const ::HIR::GenericPath& p) const
+::HIR::GenericPath Trans_Params::monomorph(const ::StaticTraitResolve& resolve, const ::HIR::GenericPath& p) const
 {
-    return ::HIR::GenericPath( p.m_path,  this->monomorph(crate, p.m_params) );
+    return ::HIR::GenericPath( p.m_path,  this->monomorph(resolve, p.m_params) );
 }
 
-::HIR::PathParams Trans_Params::monomorph(const ::HIR::Crate& crate, const ::HIR::PathParams& p) const
+::HIR::PathParams Trans_Params::monomorph(const ::StaticTraitResolve& resolve, const ::HIR::PathParams& p) const
 {
     auto rv = monomorphise_path_params_with(sp, p, this->get_cb(), false);
-    ::StaticTraitResolve    resolve { crate };
     for(auto& arg : rv.m_types)
         resolve.expand_associated_types(sp, arg);
     return rv;
 }
 
-::HIR::TypeRef Trans_Params::monomorph(const ::HIR::Crate& crate, const ::HIR::TypeRef& ty) const
+::HIR::TypeRef Trans_Params::monomorph(const ::StaticTraitResolve& resolve, const ::HIR::TypeRef& ty) const
 {
     auto rv = monomorphise_type_with(sp, ty, this->get_cb(), false);
-    ::StaticTraitResolve    resolve { crate };
     resolve.expand_associated_types(sp, rv);
     return rv;
 }
diff --git a/src/trans/trans_list.hpp b/src/trans/trans_list.hpp
index e80a2b6e..58a6030d 100644
--- a/src/trans/trans_list.hpp
+++ b/src/trans/trans_list.hpp
@@ -11,6 +11,7 @@
 #include <hir/path.hpp>
 #include <hir_typeck/common.hpp>
 
+class StaticTraitResolve;
 namespace HIR {
 class Crate;
 class Function;
@@ -30,10 +31,10 @@ struct Trans_Params
     {}
 
     t_cb_generic get_cb() const;
-    ::HIR::TypeRef monomorph(const ::HIR::Crate& crate, const ::HIR::TypeRef& p) const;
-    ::HIR::Path monomorph(const ::HIR::Crate& crate, const ::HIR::Path& p) const;
-    ::HIR::GenericPath monomorph(const ::HIR::Crate& crate, const ::HIR::GenericPath& p) const;
-    ::HIR::PathParams monomorph(const ::HIR::Crate& crate, const ::HIR::PathParams& p) const;
+    ::HIR::TypeRef monomorph(const ::StaticTraitResolve& resolve, const ::HIR::TypeRef& p) const;
+    ::HIR::Path monomorph(const ::StaticTraitResolve& resolve, const ::HIR::Path& p) const;
+    ::HIR::GenericPath monomorph(const ::StaticTraitResolve& resolve, const ::HIR::GenericPath& p) const;
+    ::HIR::PathParams monomorph(const ::StaticTraitResolve& resolve, const ::HIR::PathParams& p) const;
 
     bool has_types() const {
         return pp_method.m_types.size() > 0 || pp_impl.m_types.size() > 0;