HIR - Planning for removal of evil pointers (but not today)

5 files changed, 98 insertions, 8 deletions

diff --git a/src/hir/expr_state.hpp b/src/hir/expr_state.hpp
index 11fffe67..6151fb6b 100644
--- a/src/hir/expr_state.hpp
+++ b/src/hir/expr_state.hpp
@@ -16,8 +16,8 @@ public:
     ::HIR::SimplePath   m_mod_path;
     const ::HIR::Module&    m_module;
 
-    ::HIR::GenericParams*   m_impl_generics;
-    ::HIR::GenericParams*   m_item_generics;
+    const ::HIR::GenericParams*   m_impl_generics;
+    const ::HIR::GenericParams*   m_item_generics;
 
     ::std::vector< ::std::pair< const ::HIR::SimplePath*, const ::HIR::Trait* > >   m_traits;
 
diff --git a/src/hir/hir_ops.cpp b/src/hir/hir_ops.cpp
index 14533fb4..d9b1fb07 100644
--- a/src/hir/hir_ops.cpp
+++ b/src/hir/hir_ops.cpp
@@ -1074,6 +1074,8 @@ const ::MIR::Function* HIR::Crate::get_or_gen_mir(const ::HIR::ItemPath& ip, con
 {
     if( !ep )
     {
+        // No HIR, so has to just have MIR - from a extern crate most likely
+        assert(ep.m_mir);
         return &*ep.m_mir;
     }
     else
@@ -1096,6 +1098,7 @@ const ::MIR::Function* HIR::Crate::get_or_gen_mir(const ::HIR::ItemPath& ip, con
                 //Debug_SetStagePre("HIR Typecheck");
                 // - Can store that on the Expr, OR get it from the item path
                 typeck::ModuleState ms { const_cast<::HIR::Crate&>(*this) };
+                //ms.prepare_from_path( ip );   // <- Ideally would use this, but it's a lot of code for one usage
                 ms.m_impl_generics = ep.m_state->m_impl_generics;
                 ms.m_item_generics = ep.m_state->m_item_generics;
                 ms.m_traits = ep.m_state->m_traits;
diff --git a/src/hir_typeck/expr_visit.cpp b/src/hir_typeck/expr_visit.cpp
index d713c135..c655bc52 100644
--- a/src/hir_typeck/expr_visit.cpp
+++ b/src/hir_typeck/expr_visit.cpp
@@ -19,6 +19,83 @@ void Typecheck_Code(const typeck::ModuleState& ms, t_args& args, const ::HIR::Ty
     }
 }
 
+namespace typeck {
+    void ModuleState::prepare_from_path(const ::HIR::ItemPath& ip)
+    {
+        static Span sp;
+        ASSERT_BUG(sp, ip.parent, "prepare_from_path with too-short path - " << ip);
+        struct H {
+            static const ::HIR::Module& get_mod_for_ip(const ::HIR::Crate& crate, const ::HIR::ItemPath& ip)
+            {
+                if( ip.parent )
+                {
+                    const auto& mod = H::get_mod_for_ip(crate, *ip.parent);
+                    return mod.m_mod_items.at(ip.name)->ent.as_Module();
+                }
+                else
+                {
+                    assert(ip.crate_name);
+                    return (ip.crate_name[0] ? crate.m_ext_crates.at(ip.crate_name).m_data->m_root_module : crate.m_root_module);
+                }
+            }
+            static void add_traits_from_mod(ModuleState& ms, const ::HIR::Module& mod)
+            {
+                // In-scope traits.
+                ms.m_traits.clear();
+                for(const auto& tp : mod.m_traits)
+                {
+                    const auto& trait = ms.m_crate.get_trait_by_path(sp, tp);
+                    ms.m_traits.push_back(::std::make_pair( &tp, &trait ));
+                }
+            }
+        };
+        if( ip.parent->trait && ip.parent->ty )
+        {
+            // Trait impl
+            TODO(sp, "prepare_from_path - Trait impl " << ip);
+        }
+        else if( ip.parent->trait )
+        {
+            // Trait definition
+            //const auto& trait_mod = H::get_mod_for_ip(m_crate, *ip.parent->trait->parent);
+            //const auto& trait = trait_mod.m_mod_items.at(ip.parent->trait->name).ent.as_Trait();
+            const auto& trait = m_crate.get_trait_by_path(sp, *ip.parent->trait);
+            const auto& item = trait.m_values.at(ip.name);
+            TU_MATCH_HDRA( (item), { )
+            TU_ARMA(Function, e) {
+                m_item_generics = &e.m_params;
+                }
+            }
+        }
+        else if( ip.parent->ty )
+        {
+            // Inherent impl
+            TODO(sp, "prepare_from_path - Type impl " << ip);
+        }
+        else
+        {
+            // Namespace path
+            const auto& mod = H::get_mod_for_ip(m_crate, *ip.parent);
+            H::add_traits_from_mod(*this, mod);
+            const auto& item = mod.m_value_items.at(ip.name)->ent;
+            m_impl_generics = nullptr;
+            TU_MATCH_HDRA( (item), { )
+            TU_ARMA(Constant, e) {
+                m_item_generics = &e.m_params;
+                }
+            TU_ARMA(Static, e) {
+                //m_item_generics = &e.m_params;
+                }
+            TU_ARMA(Function, e) {
+                m_item_generics = &e.m_params;
+                }
+            TU_ARMA(StructConstant, _e) BUG(sp, ip << " is StructConstant");
+            TU_ARMA(StructConstructor, _e) BUG(sp, ip << " is StructConstructor");
+            }
+        }
+    }
+} // namespace typeck
+
 namespace {
 
 
diff --git a/src/hir_typeck/expr_visit.hpp b/src/hir_typeck/expr_visit.hpp
index 9388b1dd..fbd22704 100644
--- a/src/hir_typeck/expr_visit.hpp
+++ b/src/hir_typeck/expr_visit.hpp
@@ -12,8 +12,8 @@ namespace typeck {
     {
         const ::HIR::Crate& m_crate;
 
-        ::HIR::GenericParams*   m_impl_generics;
-        ::HIR::GenericParams*   m_item_generics;
+        const ::HIR::GenericParams*   m_impl_generics;
+        const ::HIR::GenericParams*   m_item_generics;
 
         ::std::vector< ::std::pair< const ::HIR::SimplePath*, const ::HIR::Trait* > >   m_traits;
         ::std::vector<HIR::SimplePath>  m_mod_paths;
@@ -35,17 +35,19 @@ namespace typeck {
                 ptr = nullptr;
             }
         };
-        NullOnDrop< ::HIR::GenericParams> set_impl_generics(::HIR::GenericParams& gps) {
+        NullOnDrop<const ::HIR::GenericParams> set_impl_generics(::HIR::GenericParams& gps) {
             assert( !m_impl_generics );
             m_impl_generics = &gps;
-            return NullOnDrop< ::HIR::GenericParams>(m_impl_generics);
+            return NullOnDrop<const ::HIR::GenericParams>(m_impl_generics);
         }
-        NullOnDrop< ::HIR::GenericParams> set_item_generics(::HIR::GenericParams& gps) {
+        NullOnDrop<const ::HIR::GenericParams> set_item_generics(::HIR::GenericParams& gps) {
             assert( !m_item_generics );
             m_item_generics = &gps;
-            return NullOnDrop< ::HIR::GenericParams>(m_item_generics);
+            return NullOnDrop<const ::HIR::GenericParams>(m_item_generics);
         }
 
+        void prepare_from_path(const ::HIR::ItemPath& ip);
+
         void push_traits(::HIR::ItemPath p, const ::HIR::Module& mod) {
             auto sp = Span();
             m_mod_paths.push_back( p.get_simple_path() );
diff --git a/src/hir_typeck/helpers.cpp b/src/hir_typeck/helpers.cpp
index 326ecfa9..663818e2 100644
--- a/src/hir_typeck/helpers.cpp
+++ b/src/hir_typeck/helpers.cpp
@@ -947,9 +947,17 @@ void TraitResolution::prep_indexes()
         this->m_type_equalities.insert(::std::make_pair( mv$(long_ty), mv$(short_ty) ));
         };
 
+    DEBUG("m_impl_params = " << m_impl_params << ", m_item_params = " << m_item_params);
+    if( m_impl_params ) {
+        DEBUG("- impl" << m_impl_params->fmt_args() << " " << m_impl_params->fmt_bounds());
+    }
+    if( m_item_params ) {
+        DEBUG("- fn ..." << m_item_params->fmt_args() << " " << m_item_params->fmt_bounds());
+    }
     // Obtain type equality bounds.
     // TODO: Also flatten the bounds list into known trait bounds?
     this->iterate_bounds([&](const auto& b)->bool {
+        DEBUG("[prep_indexes] " << b);
         if(const auto* bep = b.opt_TraitBound())
         {
             const auto& be = *bep;