summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/main.cpp23
-rw-r--r--src/trans/codegen.cpp60
-rw-r--r--src/trans/codegen.hpp46
-rw-r--r--src/trans/codegen_c.cpp51
-rw-r--r--src/trans/enumerate.cpp37
-rw-r--r--src/trans/main_bindings.hpp2
-rw-r--r--src/trans/mangle.cpp4
-rw-r--r--src/trans/mangling.cpp29
-rw-r--r--src/trans/mangling.hpp20
-rw-r--r--src/trans/monomorphise.cpp262
-rw-r--r--src/trans/monomorphise.hpp17
-rw-r--r--src/trans/trans_list.cpp55
-rw-r--r--src/trans/trans_list.hpp8
13 files changed, 568 insertions, 46 deletions
diff --git a/src/main.cpp b/src/main.cpp
index fdb1c7b0..2b20668e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -66,6 +66,8 @@ void init_debug_list()
g_debug_disable_map.insert( "Dump MIR" );
g_debug_disable_map.insert( "HIR Serialise" );
+ g_debug_disable_map.insert( "Trans Enumerate" );
+ g_debug_disable_map.insert( "Trans" );
// Mutate this map using an environment variable
const char* debug_string = ::std::getenv("MRUSTC_DEBUG");
@@ -406,16 +408,20 @@ int main(int argc, char *argv[])
//HIR_Serialise(params.outfile + ".meta", *hir_crate);
HIR_Serialise(params.outfile, *hir_crate);
});
+ //TransList items;
+ //CompilePhaseV("Trans Enumerate", [&]() { Trans_Enumerate_Public(*hir_crate); });
+ //CompilePhaseV("Trans Codegen", [&]() { Trans_Codegen(params.outfile + ".o", *hir_crate, items); });
// Generate a .o
//HIR_Codegen_Lib(params.outfile + ".o", *hir_crate);
// Link metatdata and object into a .rlib
break;
case ::AST::Crate::Type::RustDylib:
// Save a loadable HIR dump
- CompilePhaseV("HIR Serialise", [&]() {
- //HIR_Serialise(params.outfile + ".meta", *hir_crate);
- HIR_Serialise(params.outfile, *hir_crate);
- });
+ CompilePhaseV("HIR Serialise", [&]() { HIR_Serialise(params.outfile, *hir_crate); });
+ // - Enumerate codegen for visible and non-generic items
+ //TransList items;
+ //CompilePhaseV("Trans Enumerate", [&]() { Trans_Enumerate_Public(*hir_crate); });
+ //CompilePhaseV("Trans Codegen", [&]() { Trans_Codegen(params.outfile, *hir_crate, items); });
// Generate a .so/.dll
// TODO: Codegen and include the metadata in a non-loadable segment
break;
@@ -424,10 +430,11 @@ int main(int argc, char *argv[])
break;
case ::AST::Crate::Type::Executable:
// Generate a binary
- CompilePhaseV("Trans Enumerate", [&]() {
- Trans_Enumerate_Main(*hir_crate);
- });
- //HIR_Codegen_Main(params.outfile + ".o", *hir_crate);
+ // - Enumerate items for translation
+ TransList items = CompilePhase<TransList>("Trans Enumerate", [&]() { return Trans_Enumerate_Main(*hir_crate); });
+ // - Perform codegen
+ CompilePhaseV("Trans Codegen", [&]() { Trans_Codegen(params.outfile, *hir_crate, items); });
+ // - Invoke linker?
break;
}
}
diff --git a/src/trans/codegen.cpp b/src/trans/codegen.cpp
new file mode 100644
index 00000000..4ec48f81
--- /dev/null
+++ b/src/trans/codegen.cpp
@@ -0,0 +1,60 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/codegen.cpp
+ * - Wrapper for translation
+ */
+#include "main_bindings.hpp"
+#include "trans_list.hpp"
+#include <hir/hir.hpp>
+
+#include "codegen.hpp"
+#include "monomorphise.hpp"
+
+void Trans_Codegen(const ::std::string& outfile, const ::HIR::Crate& crate, const TransList& list)
+{
+ auto codegen = Trans_Codegen_GetGeneratorC(outfile);
+
+ // 1. Emit structure/type definitions.
+ // - Emit in the order they're needed.
+
+ // 2. Emit function prototypes
+ for(const auto& fcn : list.m_functions)
+ {
+ DEBUG("FUNCTION " << fcn.first);
+ }
+ // 3. Emit statics
+ for(const auto& ent : list.m_statics)
+ {
+ DEBUG("STATIC " << ent.first);
+
+ if( ent.second->ptr )
+ {
+ codegen->emit_static_ext(ent.first);
+ }
+ else
+ {
+ codegen->emit_static_local(ent.first, *ent.second->ptr, ent.second->pp);
+ }
+ }
+
+
+ // 4. Emit function code
+ for(const auto& ent : list.m_functions)
+ {
+ if( ent.second->ptr && ent.second->ptr->m_code.m_mir ) {
+ DEBUG("FUNCTION CODE " << ent.first);
+ if( ent.second->pp.has_types() ) {
+ auto mir = Trans_Monomorphise(crate, ent.second->pp, ent.second->ptr->m_code.m_mir);
+ codegen->emit_function_code(ent.first, *ent.second->ptr, ent.second->pp, mir);
+ }
+ else {
+ codegen->emit_function_code(ent.first, *ent.second->ptr, ent.second->pp, ent.second->ptr->m_code.m_mir);
+ }
+ }
+ }
+
+ codegen->finalise();
+}
+
diff --git a/src/trans/codegen.hpp b/src/trans/codegen.hpp
new file mode 100644
index 00000000..0aff9412
--- /dev/null
+++ b/src/trans/codegen.hpp
@@ -0,0 +1,46 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/codegen.hpp
+ * - Common class and methods for codegen
+ */
+#pragma once
+
+#include "trans_list.hpp"
+
+namespace HIR {
+ class TypeRef;
+ class Path;
+ class GenericPath;
+
+ class Function;
+ class Static;
+}
+namespace MIR {
+ class FunctionPointer;
+}
+
+
+class CodeGenerator
+{
+public:
+ virtual ~CodeGenerator() {}
+ virtual void finalise() {}
+
+ virtual void emit_tuple(const ::HIR::GenericPath& p, const ::std::vector<::HIR::TypeRef>& ) {}
+ virtual void emit_struct(const ::HIR::GenericPath& p, const ::HIR::Struct& item) {}
+ virtual void emit_union(const ::HIR::GenericPath& p, const ::HIR::Union& item) {}
+ virtual void emit_enum(const ::HIR::GenericPath& p, const ::HIR::Enum& item) {}
+
+ virtual void emit_static_ext(const ::HIR::Path& p) {}
+ virtual void emit_static_local(const ::HIR::Path& p, const ::HIR::Static& item, const Trans_Params& params) {}
+
+ virtual void emit_function_ext(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params) {}
+ virtual void emit_function_proto(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params) {}
+ virtual void emit_function_code(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params, const ::MIR::FunctionPointer& code) {}
+};
+
+
+extern ::std::unique_ptr<CodeGenerator> Trans_Codegen_GetGeneratorC(const ::std::string& outfile);
+
diff --git a/src/trans/codegen_c.cpp b/src/trans/codegen_c.cpp
new file mode 100644
index 00000000..e0ac3b30
--- /dev/null
+++ b/src/trans/codegen_c.cpp
@@ -0,0 +1,51 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/codegen_c.cpp
+ * - Code generation emitting C code
+ */
+#include "codegen.hpp"
+#include "mangling.hpp"
+#include <fstream>
+
+namespace {
+ class CodeGenerator_C:
+ public CodeGenerator
+ {
+ ::std::ofstream m_of;
+ public:
+ CodeGenerator_C(const ::std::string& outfile):
+ m_of(outfile)
+ {
+ }
+
+ ~CodeGenerator_C() {}
+
+ void finalise() override
+ {
+ }
+
+ void emit_struct(const ::HIR::GenericPath& p, const ::HIR::Struct& item) override
+ {
+ m_of << "struct s_" << Trans_Mangle(p) << " {\n";
+ m_of << "}\n";
+ }
+ //virtual void emit_union(const ::HIR::GenericPath& p, const ::HIR::Union& item);
+ //virtual void emit_enum(const ::HIR::GenericPath& p, const ::HIR::Enum& item);
+
+ //virtual void emit_static_ext(const ::HIR::Path& p);
+ //virtual void emit_static_local(const ::HIR::Path& p, const ::HIR::Static& item, const Trans_Params& params);
+
+ //virtual void emit_function_ext(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params);
+ //virtual void emit_function_proto(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params);
+ //virtual void emit_function_code(const ::HIR::Path& p, const ::HIR::Function& item, const Trans_Params& params);
+ private:
+
+ };
+}
+
+::std::unique_ptr<CodeGenerator> Trans_Codegen_GetGeneratorC(const ::std::string& outfile)
+{
+ return ::std::unique_ptr<CodeGenerator>(new CodeGenerator_C(outfile));
+}
diff --git a/src/trans/enumerate.cpp b/src/trans/enumerate.cpp
index 7dab15eb..2c918a89 100644
--- a/src/trans/enumerate.cpp
+++ b/src/trans/enumerate.cpp
@@ -494,40 +494,3 @@ void Trans_Enumerate_FillFrom(TransList& out, const ::HIR::Crate& crate, const :
}
}
-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
-{
- 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)
- resolve.expand_associated_types(sp, arg);
- ),
- (UfcsInherent,
- resolve.expand_associated_types(sp, *e2.type);
- for(auto& arg : e2.params.m_types)
- resolve.expand_associated_types(sp, arg);
- // TODO: impl params too?
- for(auto& arg : e2.impl_params.m_types)
- resolve.expand_associated_types(sp, arg);
- ),
- (UfcsKnown,
- resolve.expand_associated_types(sp, *e2.type);
- for(auto& arg : e2.trait.m_params.m_types)
- resolve.expand_associated_types(sp, arg);
- for(auto& arg : e2.params.m_types)
- resolve.expand_associated_types(sp, arg);
- ),
- (UfcsUnknown,
- BUG(sp, "Encountered UfcsUnknown");
- )
- )
- return rv;
-}
-
diff --git a/src/trans/main_bindings.hpp b/src/trans/main_bindings.hpp
index e5615fa9..b8391cb8 100644
--- a/src/trans/main_bindings.hpp
+++ b/src/trans/main_bindings.hpp
@@ -15,3 +15,5 @@ class Crate;
extern TransList Trans_Enumerate_Main(const ::HIR::Crate& crate);
extern TransList Trans_Enumerate_Public(const ::HIR::Crate& crate);
+
+extern void Trans_Codegen(const ::std::string& outfile, const ::HIR::Crate& crate, const TransList& list);
diff --git a/src/trans/mangle.cpp b/src/trans/mangle.cpp
new file mode 100644
index 00000000..030aadce
--- /dev/null
+++ b/src/trans/mangle.cpp
@@ -0,0 +1,4 @@
+
+extern ::std::string Trans_Mangle(const ::HIR::GenericPath& path);
+extern ::std::string Trans_Mangle(const ::HIR::Path& path);
+extern ::std::string Trans_Mangle(const ::HIR::TypeRef& ty);
diff --git a/src/trans/mangling.cpp b/src/trans/mangling.cpp
new file mode 100644
index 00000000..4e47094c
--- /dev/null
+++ b/src/trans/mangling.cpp
@@ -0,0 +1,29 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/mangling.hpp
+ * - Name mangling support
+ */
+#include "mangling.hpp"
+#include <hir/type.hpp>
+#include <hir/path.hpp>
+
+::std::string Trans_Mangle(const ::HIR::GenericPath& path)
+{
+ ::std::stringstream ss;
+ ss << "_ZN" << path.m_path.m_crate_name.size() << path.m_path.m_crate_name;
+ for(const auto& comp : path.m_path.m_components)
+ ss << comp.size() << comp;
+
+ return ss.str();
+}
+::std::string Trans_Mangle(const ::HIR::Path& path)
+{
+ return "";
+}
+::std::string Trans_Mangle(const ::HIR::TypeRef& ty)
+{
+ return "";
+}
+
diff --git a/src/trans/mangling.hpp b/src/trans/mangling.hpp
new file mode 100644
index 00000000..b9ead23d
--- /dev/null
+++ b/src/trans/mangling.hpp
@@ -0,0 +1,20 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/mangling.hpp
+ * - Name mangling support
+ */
+#pragma once
+#include <string>
+
+namespace HIR {
+ class GenericPath;
+ class Path;
+ class TypeRef;
+}
+
+extern ::std::string Trans_Mangle(const ::HIR::GenericPath& path);
+extern ::std::string Trans_Mangle(const ::HIR::Path& path);
+extern ::std::string Trans_Mangle(const ::HIR::TypeRef& ty);
+
diff --git a/src/trans/monomorphise.cpp b/src/trans/monomorphise.cpp
new file mode 100644
index 00000000..bca5ce14
--- /dev/null
+++ b/src/trans/monomorphise.cpp
@@ -0,0 +1,262 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/monomorphise.hpp
+ * - MIR monomorphisation
+ */
+#include "monomorphise.hpp"
+#include <mir/mir.hpp>
+
+
+namespace {
+ ::MIR::LValue monomorph_LValue(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::LValue& tpl)
+ {
+ TU_MATCHA( (tpl), (e),
+ (Variable, return e; ),
+ (Temporary, return e; ),
+ (Argument, return e; ),
+ (Return, return e; ),
+ (Static,
+ return params.monomorph(crate, e);
+ ),
+ (Field,
+ return ::MIR::LValue::make_Field({
+ box$(monomorph_LValue(crate, params, *e.val)),
+ e.field_index
+ });
+ ),
+ (Deref,
+ return ::MIR::LValue::make_Deref({
+ box$(monomorph_LValue(crate, params, *e.val))
+ });
+ ),
+ (Index,
+ return ::MIR::LValue::make_Index({
+ box$(monomorph_LValue(crate, params, *e.val)),
+ box$(monomorph_LValue(crate, params, *e.idx))
+ });
+ ),
+ (Downcast,
+ return ::MIR::LValue::make_Field({
+ box$(monomorph_LValue(crate, 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> rv;
+ rv.reserve( tpl.size() );
+ for(const auto& v : tpl)
+ rv.push_back( monomorph_LValue(crate, params, v) );
+ return rv;
+ }
+}
+
+::MIR::FunctionPointer Trans_Monomorphise(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl)
+{
+ static Span sp;
+ TRACE_FUNCTION;
+
+ ::MIR::Function output;
+
+ // 1. Monomorphise locals and temporaries
+ output.named_variables.reserve( tpl->named_variables.size() );
+ for(const auto& var : tpl->named_variables)
+ {
+ output.named_variables.push_back( params.monomorph(crate, var) );
+ }
+ output.temporaries.reserve( tpl->temporaries.size() );
+ for(const auto& ty : tpl->temporaries)
+ {
+ output.named_variables.push_back( params.monomorph(crate, ty) );
+ }
+
+ // 2. Monomorphise all paths
+ // 3. Convert virtual dispatch to vtable load
+ output.blocks.reserve( tpl->blocks.size() );
+ for(const auto& block : tpl->blocks)
+ {
+ ::std::vector< ::MIR::Statement> statements;
+
+ statements.reserve( block.statements.size() );
+ for(const auto& stmt : block.statements)
+ {
+ assert( stmt.is_Drop() || stmt.is_Assign() );
+ if( stmt.is_Drop() )
+ {
+ const auto& e = stmt.as_Drop();
+ statements.push_back( ::MIR::Statement::make_Drop({
+ e.kind,
+ monomorph_LValue(crate, params, e.slot)
+ }) );
+ }
+ else
+ {
+ const auto& e = stmt.as_Assign();
+
+ ::MIR::RValue rval;
+ TU_MATCHA( (e.src), (se),
+ (Use,
+ rval = ::MIR::RValue( monomorph_LValue(crate, params, se) );
+ ),
+ (Constant,
+ TU_MATCHA( (se), (ce),
+ (Int,
+ rval = ::MIR::Constant::make_Int(ce);
+ ),
+ (Uint,
+ rval = ::MIR::Constant::make_Uint(ce);
+ ),
+ (Float,
+ rval = ::MIR::Constant::make_Float(ce);
+ ),
+ (Bool,
+ rval = ::MIR::Constant::make_Bool(ce);
+ ),
+ (Bytes,
+ rval = ::MIR::Constant(ce);
+ ),
+ (StaticString,
+ rval = ::MIR::Constant(ce);
+ ),
+ (Const,
+ rval = ::MIR::Constant::make_Const({
+ params.monomorph(crate, ce.p)
+ });
+ ),
+ (ItemAddr,
+ auto p = params.monomorph(crate, 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.
+ rval = ::MIR::Constant( mv$(p) );
+ )
+ )
+ ),
+ (SizedArray,
+ rval = ::MIR::RValue::make_SizedArray({
+ monomorph_LValue(crate, params, se.val),
+ se.count
+ });
+ ),
+ (Borrow,
+ rval = ::MIR::RValue::make_Borrow({
+ se.region, se.type,
+ monomorph_LValue(crate, params, se.val)
+ });
+ ),
+ (Cast,
+ rval = ::MIR::RValue::make_Cast({
+ monomorph_LValue(crate, params, se.val),
+ params.monomorph(crate, se.type)
+ });
+ ),
+ (BinOp,
+ rval = ::MIR::RValue::make_BinOp({
+ monomorph_LValue(crate, params, se.val_l),
+ se.op,
+ monomorph_LValue(crate, params, se.val_r)
+ });
+ ),
+ (UniOp,
+ rval = ::MIR::RValue::make_UniOp({
+ monomorph_LValue(crate, params, se.val),
+ se.op
+ });
+ ),
+ (DstMeta,
+ auto lv = monomorph_LValue(crate, 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) });
+ ),
+ (MakeDst,
+ rval = ::MIR::RValue::make_MakeDst({
+ monomorph_LValue(crate, params, se.ptr_val),
+ monomorph_LValue(crate, params, se.meta_val)
+ });
+ ),
+ (Tuple,
+ rval = ::MIR::RValue::make_Tuple({
+ monomorph_LValue_list(crate, params, se.vals)
+ });
+ ),
+ (Array,
+ rval = ::MIR::RValue::make_Array({
+ monomorph_LValue_list(crate, params, se.vals)
+ });
+ ),
+ // Create a new instance of a union (and eventually enum)
+ (Variant,
+ rval = ::MIR::RValue::make_Variant({
+ params.monomorph(crate, se.path),
+ se.index,
+ monomorph_LValue(crate, params, se.val)
+ });
+ ),
+ // Create a new instance of a struct (or enum)
+ (Struct,
+ rval = ::MIR::RValue::make_Struct({
+ params.monomorph(crate, se.path),
+ monomorph_LValue_list(crate, params, se.vals)
+ });
+ )
+ )
+
+ statements.push_back( ::MIR::Statement::make_Assign({
+ monomorph_LValue(crate, params, e.dst),
+ mv$(rval)
+ }) );
+ }
+ }
+
+ ::MIR::Terminator terminator;
+
+ TU_MATCHA( (block.terminator), (e),
+ (Incomplete,
+ BUG(sp, "Incomplete block");
+ ),
+ (Return,
+ terminator = e;
+ ),
+ (Diverge,
+ terminator = e;
+ ),
+ (Goto,
+ terminator = e;
+ ),
+ (Panic,
+ terminator = e;
+ ),
+ (If,
+ terminator = ::MIR::Terminator::make_If({
+ monomorph_LValue(crate, params, e.cond),
+ e.bb0, e.bb1
+ });
+ ),
+ (Switch,
+ terminator = ::MIR::Terminator::make_Switch({
+ monomorph_LValue(crate, params, e.val),
+ e.targets
+ });
+ ),
+ (Call,
+ terminator = ::MIR::Terminator::make_Call({
+ e.ret_block, e.panic_block,
+ monomorph_LValue(crate, params, e.ret_val),
+ monomorph_LValue(crate, params, e.fcn_val),
+ monomorph_LValue_list(crate, params, e.args)
+ });
+ )
+ )
+
+ output.blocks.push_back( ::MIR::BasicBlock { mv$(statements), mv$(terminator) } );
+ }
+
+ return ::MIR::FunctionPointer( box$(output).release() );
+}
diff --git a/src/trans/monomorphise.hpp b/src/trans/monomorphise.hpp
new file mode 100644
index 00000000..16a5d742
--- /dev/null
+++ b/src/trans/monomorphise.hpp
@@ -0,0 +1,17 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/monomorphise.hpp
+ * - MIR monomorphisation
+ */
+#pragma once
+
+#include <mir/mir_ptr.hpp>
+#include "trans_list.hpp"
+
+namespace HIR {
+ class Crate;
+}
+
+extern ::MIR::FunctionPointer Trans_Monomorphise(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl);
diff --git a/src/trans/trans_list.cpp b/src/trans/trans_list.cpp
index 977894f4..38e80468 100644
--- a/src/trans/trans_list.cpp
+++ b/src/trans/trans_list.cpp
@@ -6,6 +6,7 @@
* - A list of items that require translation
*/
#include "trans_list.hpp"
+#include <hir_typeck/static.hpp> // StaticTraitResolve
TransList_Function* TransList::add_function(::HIR::Path p)
{
@@ -37,3 +38,57 @@ TransList_Static* TransList::add_static(::HIR::Path p)
return nullptr;
}
}
+
+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
+{
+ 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)
+ resolve.expand_associated_types(sp, arg);
+ ),
+ (UfcsInherent,
+ resolve.expand_associated_types(sp, *e2.type);
+ for(auto& arg : e2.params.m_types)
+ resolve.expand_associated_types(sp, arg);
+ // TODO: impl params too?
+ for(auto& arg : e2.impl_params.m_types)
+ resolve.expand_associated_types(sp, arg);
+ ),
+ (UfcsKnown,
+ resolve.expand_associated_types(sp, *e2.type);
+ for(auto& arg : e2.trait.m_params.m_types)
+ resolve.expand_associated_types(sp, arg);
+ for(auto& arg : e2.params.m_types)
+ resolve.expand_associated_types(sp, arg);
+ ),
+ (UfcsUnknown,
+ BUG(sp, "Encountered UfcsUnknown");
+ )
+ )
+ return rv;
+}
+
+::HIR::GenericPath Trans_Params::monomorph(const ::HIR::Crate& crate, const ::HIR::GenericPath& p) const
+{
+ auto rv = monomorphise_genericpath_with(sp, p, this->get_cb(), false);
+ ::StaticTraitResolve resolve { crate };
+ for(auto& arg : rv.m_params.m_types)
+ resolve.expand_associated_types(sp, arg);
+ return rv;
+}
+
+::HIR::TypeRef Trans_Params::monomorph(const ::HIR::Crate& crate, 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 78ebd264..1297d2c2 100644
--- a/src/trans/trans_list.hpp
+++ b/src/trans/trans_list.hpp
@@ -32,6 +32,11 @@ 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;
+
+ bool has_types() const {
+ return pp_method.m_types.size() > 0 || pp_impl.m_types.size() > 0;
+ }
};
struct TransList_Function
@@ -47,9 +52,10 @@ struct TransList_Static
class TransList
{
+public:
::std::map< ::HIR::Path, ::std::unique_ptr<TransList_Function> > m_functions;
::std::map< ::HIR::Path, ::std::unique_ptr<TransList_Static> > m_statics;
-public:
+
TransList_Function* add_function(::HIR::Path p);
TransList_Static* add_static(::HIR::Path p);
};
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-02 09:44:57 +0000