summaryrefslogtreecommitdiff
path: root/src/hir/serialise.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/hir/serialise.cpp')
-rw-r--r--src/hir/serialise.cpp368
1 files changed, 140 insertions, 228 deletions
diff --git a/src/hir/serialise.cpp b/src/hir/serialise.cpp
index 0fad2942..506245c1 100644
--- a/src/hir/serialise.cpp
+++ b/src/hir/serialise.cpp
@@ -10,135 +10,47 @@
#include <serialiser_texttree.hpp>
#include <macro_rules/macro_rules.hpp>
#include <mir/mir.hpp>
+#include "serialise_lowlevel.hpp"
namespace {
class HirSerialiser
{
- ::std::ostream& m_os;
+ ::HIR::serialise::Writer& m_out;
public:
- HirSerialiser(::std::ostream& os):
- m_os(os)
+ HirSerialiser(::HIR::serialise::Writer& out):
+ m_out( out )
{}
- void write_u8(uint8_t v) {
- m_os.write(reinterpret_cast<const char*>(&v), 1);
- }
- void write_u16(uint16_t v) {
- write_u8(v & 0xFF);
- write_u8(v >> 8);
- }
- void write_u32(uint32_t v) {
- write_u8(v & 0xFF);
- write_u8(v >> 8);
- write_u8(v >> 16);
- write_u8(v >> 24);
- }
- void write_u64(uint64_t v) {
- write_u8(v & 0xFF);
- write_u8(v >> 8);
- write_u8(v >> 16);
- write_u8(v >> 24);
- write_u8(v >> 32);
- write_u8(v >> 40);
- write_u8(v >> 48);
- write_u8(v >> 56);
- }
- // Variable-length encoded u64 (for array sizes)
- void write_u64c(uint64_t v) {
- if( v < (1<<7) ) {
- write_u8(v);
- }
- else if( v < (1<<(6+16)) ) {
- write_u8( 0x80 + (v >> 16)); // 0x80 -- 0xB0
- write_u8(v >> 8);
- write_u8(v);
- }
- else if( v < (1ul << (5 + 32)) ) {
- write_u8( 0xC0 + (v >> 32)); // 0x80 -- 0xB0
- write_u8(v >> 24);
- write_u8(v >> 16);
- write_u8(v >> 8);
- write_u8(v);
- }
- else {
- write_u8(0xFF);
- write_u64(v);
- }
- }
- void write_i64c(int64_t v) {
- // Convert from 2's completement
- bool sign = (v < 0);
- uint64_t va = (v < 0 ? -v : v);
- va <<= 1;
- va |= (sign ? 1 : 0);
- write_u64c(va);
- }
- void write_double(double v) {
- m_os.write(reinterpret_cast<const char*>(&v), sizeof v);
- }
- void write_tag(unsigned int t) {
- assert(t < 256);
- write_u8( static_cast<uint8_t>(t) );
- }
- void write_count(size_t c) {
- //DEBUG("c = " << c);
- if(c < 0xFE) {
- write_u8( static_cast<uint8_t>(c) );
- }
- else if( c == ~0u ) {
- write_u8( 0xFF );
- }
- else {
- assert(c < (1u<<16));
- write_u8( 0xFE );
- write_u16( static_cast<uint16_t>(c) );
- }
- }
- void write_string(const ::std::string& v) {
- if(v.size() < 128) {
- write_u8( static_cast<uint8_t>(v.size()) );
- }
- else {
- assert(v.size() < (1u<<(16+7)));
- write_u8( static_cast<uint8_t>(128 + (v.size() >> 16)) );
- write_u16( static_cast<uint16_t>(v.size() & 0xFFFF) );
- }
- m_os.write(v.data(), v.size());
- }
- void write_bool(bool v) {
- write_u8(v ? 0xFF : 0x00);
- }
-
template<typename V>
void serialise_strmap(const ::std::map< ::std::string,V>& map)
{
- write_count(map.size());
+ m_out.write_count(map.size());
for(const auto& v : map) {
- write_string(v.first);
+ m_out.write_string(v.first);
serialise(v.second);
}
}
template<typename V>
void serialise_strmap(const ::std::unordered_map< ::std::string,V>& map)
{
- write_count(map.size());
+ m_out.write_count(map.size());
for(const auto& v : map) {
DEBUG("- " << v.first);
- write_string(v.first);
+ m_out.write_string(v.first);
serialise(v.second);
}
}
template<typename T>
void serialise_vec(const ::std::vector<T>& vec)
{
- write_count(vec.size());
+ m_out.write_count(vec.size());
for(const auto& i : vec)
serialise(i);
}
template<typename T>
void serialise(const ::HIR::VisEnt<T>& e)
{
- write_bool(e.is_public);
+ m_out.write_bool(e.is_public);
serialise(e.ent);
}
template<typename T>
@@ -147,13 +59,13 @@ namespace {
}
template<typename T>
void serialise(const ::std::pair< ::std::string, T>& e) {
- write_string(e.first);
+ m_out.write_string(e.first);
serialise(e.second);
}
void serialise_type(const ::HIR::TypeRef& ty)
{
- write_tag( ty.m_data.tag() );
+ m_out.write_tag( ty.m_data.tag() );
TU_MATCHA( (ty.m_data), (e),
(Infer,
// BAAD
@@ -161,18 +73,18 @@ namespace {
(Diverge,
),
(Primitive,
- write_tag( static_cast<int>(e) );
+ m_out.write_tag( static_cast<int>(e) );
),
(Path,
serialise_path(e.path);
),
(Generic,
- write_string(e.name);
- write_u16(e.binding);
+ m_out.write_string(e.name);
+ m_out.write_u16(e.binding);
),
(TraitObject,
serialise_traitpath(e.m_trait);
- write_count(e.m_markers.size());
+ m_out.write_count(e.m_markers.size());
for(const auto& m : e.m_markers)
serialise_genericpath(m);
//write_string(e.lifetime); // TODO: Need a better type
@@ -180,27 +92,27 @@ namespace {
(Array,
assert(e.size_val != ~0u);
serialise_type(*e.inner);
- write_u64c(e.size_val);
+ m_out.write_u64c(e.size_val);
),
(Slice,
serialise_type(*e.inner);
),
(Tuple,
- write_count(e.size());
+ m_out.write_count(e.size());
for(const auto& st : e)
serialise_type(st);
),
(Borrow,
- write_tag(static_cast<int>(e.type));
+ m_out.write_tag(static_cast<int>(e.type));
serialise_type(*e.inner);
),
(Pointer,
- write_tag(static_cast<int>(e.type));
+ m_out.write_tag(static_cast<int>(e.type));
serialise_type(*e.inner);
),
(Function,
- write_bool(e.is_unsafe);
- write_string(e.m_abi);
+ m_out.write_bool(e.is_unsafe);
+ m_out.write_string(e.m_abi);
serialise_type(*e.m_rettype);
serialise_vec(e.m_arg_types);
),
@@ -213,14 +125,14 @@ namespace {
void serialise_simplepath(const ::HIR::SimplePath& path)
{
//TRACE_FUNCTION_F("path="<<path);
- write_string(path.m_crate_name);
- write_count(path.m_components.size());
+ m_out.write_string(path.m_crate_name);
+ m_out.write_count(path.m_components.size());
for(const auto& c : path.m_components)
- write_string(c);
+ m_out.write_string(c);
}
void serialise_pathparams(const ::HIR::PathParams& pp)
{
- write_count(pp.m_types.size());
+ m_out.write_count(pp.m_types.size());
for(const auto& t : pp.m_types)
serialise_type(t);
}
@@ -241,20 +153,20 @@ namespace {
TRACE_FUNCTION_F("path="<<path);
TU_MATCHA( (path.m_data), (e),
(Generic,
- write_tag(0);
+ m_out.write_tag(0);
serialise_genericpath(e);
),
(UfcsInherent,
- write_tag(1);
+ m_out.write_tag(1);
serialise_type(*e.type);
- write_string(e.item);
+ m_out.write_string(e.item);
serialise_pathparams(e.params);
),
(UfcsKnown,
- write_tag(2);
+ m_out.write_tag(2);
serialise_type(*e.type);
serialise_genericpath(e.trait);
- write_string(e.item);
+ m_out.write_string(e.item);
serialise_pathparams(e.params);
),
(UfcsUnknown,
@@ -272,25 +184,25 @@ namespace {
serialise_vec(params.m_bounds);
}
void serialise(const ::HIR::TypeParamDef& pd) {
- write_string(pd.m_name);
+ m_out.write_string(pd.m_name);
serialise_type(pd.m_default);
- write_bool(pd.m_is_sized);
+ m_out.write_bool(pd.m_is_sized);
}
void serialise(const ::HIR::GenericBound& b) {
TU_MATCHA( (b), (e),
(Lifetime,
- write_tag(0);
+ m_out.write_tag(0);
),
(TypeLifetime,
- write_tag(1);
+ m_out.write_tag(1);
),
(TraitBound,
- write_tag(2);
+ m_out.write_tag(2);
serialise_type(e.type);
serialise_traitpath(e.trait);
),
(TypeEquality,
- write_tag(3);
+ m_out.write_tag(3);
serialise_type(e.type);
serialise_type(e.other_type);
)
@@ -302,16 +214,16 @@ namespace {
{
serialise_module(crate.m_root_module);
- write_count(crate.m_type_impls.size());
+ m_out.write_count(crate.m_type_impls.size());
for(const auto& impl : crate.m_type_impls) {
serialise_typeimpl(impl);
}
- write_count(crate.m_trait_impls.size());
+ m_out.write_count(crate.m_trait_impls.size());
for(const auto& tr_impl : crate.m_trait_impls) {
serialise_simplepath(tr_impl.first);
serialise_traitimpl(tr_impl.second);
}
- write_count(crate.m_marker_impls.size());
+ m_out.write_count(crate.m_marker_impls.size());
for(const auto& tr_impl : crate.m_marker_impls) {
serialise_simplepath(tr_impl.first);
serialise_markerimpl(tr_impl.second);
@@ -320,9 +232,9 @@ namespace {
serialise_strmap(crate.m_exported_macros);
serialise_strmap(crate.m_lang_items);
- write_count(crate.m_ext_crates.size());
+ m_out.write_count(crate.m_ext_crates.size());
for(const auto& ext : crate.m_ext_crates)
- write_string(ext.first);
+ m_out.write_string(ext.first);
}
void serialise_module(const ::HIR::Module& mod)
{
@@ -339,18 +251,18 @@ namespace {
serialise_generics(impl.m_params);
serialise_type(impl.m_type);
- write_count(impl.m_methods.size());
+ m_out.write_count(impl.m_methods.size());
for(const auto& v : impl.m_methods) {
- write_string(v.first);
- write_bool(v.second.is_pub);
- write_bool(v.second.is_specialisable);
+ m_out.write_string(v.first);
+ m_out.write_bool(v.second.is_pub);
+ m_out.write_bool(v.second.is_specialisable);
serialise(v.second.data);
}
- write_count(impl.m_constants.size());
+ m_out.write_count(impl.m_constants.size());
for(const auto& v : impl.m_constants) {
- write_string(v.first);
- write_bool(v.second.is_pub);
- write_bool(v.second.is_specialisable);
+ m_out.write_string(v.first);
+ m_out.write_bool(v.second.is_pub);
+ m_out.write_bool(v.second.is_specialisable);
serialise(v.second.data);
}
// m_src_module doesn't matter after typeck
@@ -362,25 +274,25 @@ namespace {
serialise_pathparams(impl.m_trait_args);
serialise_type(impl.m_type);
- write_count(impl.m_methods.size());
+ m_out.write_count(impl.m_methods.size());
for(const auto& v : impl.m_methods) {
DEBUG("fn " << v.first);
- write_string(v.first);
- write_bool(v.second.is_specialisable);
+ m_out.write_string(v.first);
+ m_out.write_bool(v.second.is_specialisable);
serialise(v.second.data);
}
- write_count(impl.m_constants.size());
+ m_out.write_count(impl.m_constants.size());
for(const auto& v : impl.m_constants) {
DEBUG("const " << v.first);
- write_string(v.first);
- write_bool(v.second.is_specialisable);
+ m_out.write_string(v.first);
+ m_out.write_bool(v.second.is_specialisable);
serialise(v.second.data);
}
- write_count(impl.m_types.size());
+ m_out.write_count(impl.m_types.size());
for(const auto& v : impl.m_types) {
DEBUG("type " << v.first);
- write_string(v.first);
- write_bool(v.second.is_specialisable);
+ m_out.write_string(v.first);
+ m_out.write_bool(v.second.is_specialisable);
serialise(v.second.data);
}
// m_src_module doesn't matter after typeck
@@ -389,7 +301,7 @@ namespace {
{
serialise_generics(impl.m_params);
serialise_pathparams(impl.m_trait_args);
- write_bool(impl.is_positive);
+ m_out.write_bool(impl.is_positive);
serialise_type(impl.m_type);
}
@@ -403,7 +315,7 @@ namespace {
serialise_traitpath(p);
}
void serialise(const ::std::string& v) {
- write_string(v);
+ m_out.write_string(v);
}
void serialise(const ::MacroRulesPtr& mac)
@@ -414,12 +326,12 @@ namespace {
{
//m_exported: IGNORE, should be set
serialise_vec(mac.m_rules);
- write_string(mac.m_source_crate);
+ m_out.write_string(mac.m_source_crate);
}
void serialise(const ::MacroPatEnt& pe) {
- write_string(pe.name);
- write_count(pe.name_index);
- write_tag( static_cast<int>(pe.type) );
+ m_out.write_string(pe.name);
+ m_out.write_count(pe.name_index);
+ m_out.write_tag( static_cast<int>(pe.type) );
if( pe.type == ::MacroPatEnt::PAT_TOKEN ) {
serialise(pe.tok);
}
@@ -436,23 +348,23 @@ namespace {
void serialise(const ::MacroExpansionEnt& ent) {
TU_MATCHA( (ent), (e),
(Token,
- write_tag(0);
+ m_out.write_tag(0);
serialise(e);
),
(NamedValue,
- write_tag(1);
- write_u8(e >> 24);
- write_count(e & 0x00FFFFFF);
+ m_out.write_tag(1);
+ m_out.write_u8(e >> 24);
+ m_out.write_count(e & 0x00FFFFFF);
),
(Loop,
- write_tag(2);
+ m_out.write_tag(2);
serialise_vec(e.entries);
serialise(e.joiner);
// ::std::map<unsigned int,bool>
- write_count(e.variables.size());
+ m_out.write_count(e.variables.size());
for(const auto& var : e.variables) {
- write_count(var.first);
- write_bool(var.second);
+ m_out.write_count(var.first);
+ m_out.write_bool(var.second);
}
)
)
@@ -465,12 +377,12 @@ namespace {
tok.serialise( ser );
}
- write_string(tmp.str());
+ m_out.write_string(tmp.str());
}
void serialise(const ::HIR::Literal& lit)
{
- write_tag(lit.tag());
+ m_out.write_tag(lit.tag());
TU_MATCHA( (lit), (e),
(Invalid,
//BUG(Span(), "Literal::Invalid encountered in HIR");
@@ -479,27 +391,27 @@ namespace {
serialise_vec(e);
),
(Variant,
- write_count(e.idx);
+ m_out.write_count(e.idx);
serialise_vec(e.vals);
),
(Integer,
- write_u64(e);
+ m_out.write_u64(e);
),
(Float,
- write_double(e);
+ m_out.write_double(e);
),
(BorrowOf,
serialise_path(e);
),
(String,
- write_string(e);
+ m_out.write_string(e);
)
)
}
void serialise(const ::HIR::ExprPtr& exp)
{
- write_bool( (bool)exp.m_mir );
+ m_out.write_bool( (bool)exp.m_mir );
if( exp.m_mir ) {
serialise(*exp.m_mir);
}
@@ -520,21 +432,21 @@ namespace {
{
TU_MATCHA( (stmt), (e),
(Assign,
- write_tag(0);
+ m_out.write_tag(0);
serialise(e.dst);
serialise(e.src);
),
(Drop,
- write_tag(1);
+ m_out.write_tag(1);
assert(e.kind == ::MIR::eDropKind::DEEP || e.kind == ::MIR::eDropKind::SHALLOW);
- write_bool(e.kind == ::MIR::eDropKind::DEEP);
+ m_out.write_bool(e.kind == ::MIR::eDropKind::DEEP);
serialise(e.slot);
)
)
}
void serialise(const ::MIR::Terminator& term)
{
- write_tag( static_cast<int>(term.tag()) );
+ m_out.write_tag( static_cast<int>(term.tag()) );
TU_MATCHA( (term), (e),
(Incomplete,
// NOTE: loops that diverge (don't break) leave a dangling bb
@@ -545,25 +457,25 @@ namespace {
(Diverge,
),
(Goto,
- write_count(e);
+ m_out.write_count(e);
),
(Panic,
- write_count(e.dst);
+ m_out.write_count(e.dst);
),
(If,
serialise(e.cond);
- write_count(e.bb0);
- write_count(e.bb1);
+ m_out.write_count(e.bb0);
+ m_out.write_count(e.bb1);
),
(Switch,
serialise(e.val);
- write_count(e.targets.size());
+ m_out.write_count(e.targets.size());
for(auto t : e.targets)
- write_count(t);
+ m_out.write_count(t);
),
(Call,
- write_count(e.ret_block);
- write_count(e.panic_block);
+ m_out.write_count(e.ret_block);
+ m_out.write_count(e.panic_block);
serialise(e.ret_val);
serialise(e.fcn_val);
serialise_vec(e.args);
@@ -573,16 +485,16 @@ namespace {
void serialise(const ::MIR::LValue& lv)
{
TRACE_FUNCTION_F("LValue = "<<lv);
- write_tag( static_cast<int>(lv.tag()) );
+ m_out.write_tag( static_cast<int>(lv.tag()) );
TU_MATCHA( (lv), (e),
(Variable,
- write_count(e);
+ m_out.write_count(e);
),
(Temporary,
- write_count(e.idx);
+ m_out.write_count(e.idx);
),
(Argument,
- write_count(e.idx);
+ m_out.write_count(e.idx);
),
(Static,
serialise_path(e);
@@ -591,7 +503,7 @@ namespace {
),
(Field,
serialise(e.val);
- write_count(e.field_index);
+ m_out.write_count(e.field_index);
),
(Deref,
serialise(e.val);
@@ -602,14 +514,14 @@ namespace {
),
(Downcast,
serialise(e.val);
- write_count(e.variant_index);
+ m_out.write_count(e.variant_index);
)
)
}
void serialise(const ::MIR::RValue& val)
{
TRACE_FUNCTION_F("RValue = "<<val);
- write_tag( val.tag() );
+ m_out.write_tag( val.tag() );
TU_MATCHA( (val), (e),
(Use,
serialise(e);
@@ -619,11 +531,11 @@ namespace {
),
(SizedArray,
serialise(e.val);
- write_u64c(e.count);
+ m_out.write_u64c(e.count);
),
(Borrow,
// TODO: Region?
- write_tag( static_cast<int>(e.type) );
+ m_out.write_tag( static_cast<int>(e.type) );
serialise(e.val);
),
(Cast,
@@ -632,12 +544,12 @@ namespace {
),
(BinOp,
serialise(e.val_l);
- write_tag( static_cast<int>(e.op) );
+ m_out.write_tag( static_cast<int>(e.op) );
serialise(e.val_r);
),
(UniOp,
serialise(e.val);
- write_tag( static_cast<int>(e.op) );
+ m_out.write_tag( static_cast<int>(e.op) );
),
(DstMeta,
serialise(e.val);
@@ -660,26 +572,26 @@ namespace {
}
void serialise(const ::MIR::Constant& v)
{
- write_tag(v.tag());
+ m_out.write_tag(v.tag());
TU_MATCHA( (v), (e),
(Int,
- write_i64c(e);
+ m_out.write_i64c(e);
),
(Uint,
- write_u64c(e);
+ m_out.write_u64c(e);
),
(Float,
- write_double(e);
+ m_out.write_double(e);
),
(Bool,
- write_bool(e);
+ m_out.write_bool(e);
),
(Bytes,
- write_count(e.size());
- m_os.write( reinterpret_cast<const char*>(e.data()), e.size() );
+ m_out.write_count(e.size());
+ m_out.write( e.data(), e.size() );
),
(StaticString,
- write_string(e);
+ m_out.write_string(e);
),
(Const,
serialise_path(e.p);
@@ -694,27 +606,27 @@ namespace {
{
TU_MATCHA( (item), (e),
(Import,
- write_tag(0);
+ m_out.write_tag(0);
serialise_simplepath(e);
),
(Module,
- write_tag(1);
+ m_out.write_tag(1);
serialise_module(e);
),
(TypeAlias,
- write_tag(2);
+ m_out.write_tag(2);
serialise(e);
),
(Enum,
- write_tag(3);
+ m_out.write_tag(3);
serialise(e);
),
(Struct,
- write_tag(4);
+ m_out.write_tag(4);
serialise(e);
),
(Trait,
- write_tag(5);
+ m_out.write_tag(5);
serialise(e);
)
)
@@ -723,27 +635,27 @@ namespace {
{
TU_MATCHA( (item), (e),
(Import,
- write_tag(0);
+ m_out.write_tag(0);
serialise_simplepath(e);
),
(Constant,
- write_tag(1);
+ m_out.write_tag(1);
serialise(e);
),
(Static,
- write_tag(2);
+ m_out.write_tag(2);
serialise(e);
),
(StructConstant,
- write_tag(3);
+ m_out.write_tag(3);
serialise_simplepath(e.ty);
),
(Function,
- write_tag(4);
+ m_out.write_tag(4);
serialise(e);
),
(StructConstructor,
- write_tag(5);
+ m_out.write_tag(5);
serialise_simplepath(e.ty);
)
)
@@ -754,16 +666,16 @@ namespace {
{
TRACE_FUNCTION_F("_function:");
- write_tag( static_cast<int>(fcn.m_receiver) );
- write_string(fcn.m_abi);
- write_bool(fcn.m_unsafe);
- write_bool(fcn.m_const);
+ m_out.write_tag( static_cast<int>(fcn.m_receiver) );
+ m_out.write_string(fcn.m_abi);
+ m_out.write_bool(fcn.m_unsafe);
+ m_out.write_bool(fcn.m_const);
serialise_generics(fcn.m_params);
- write_count(fcn.m_args.size());
+ m_out.write_count(fcn.m_args.size());
for(const auto& a : fcn.m_args)
serialise(a.second);
- write_bool(fcn.m_variadic);
+ m_out.write_bool(fcn.m_variadic);
serialise(fcn.m_return);
DEBUG("m_args = " << fcn.m_args);
@@ -782,7 +694,7 @@ namespace {
{
TRACE_FUNCTION_F("_static:");
- write_bool(item.m_is_mut);
+ m_out.write_bool(item.m_is_mut);
serialise(item.m_type);
// NOTE: Omit the rest, not generic and emitted as part of the image.
}
@@ -796,12 +708,12 @@ namespace {
void serialise(const ::HIR::Enum& ta)
{
serialise_generics(ta.m_params);
- write_tag( static_cast<int>(ta.m_repr) );
+ m_out.write_tag( static_cast<int>(ta.m_repr) );
serialise_vec( ta.m_variants );
}
void serialise(const ::HIR::Enum::Variant& v)
{
- write_tag( v.tag() );
+ m_out.write_tag( v.tag() );
TU_MATCHA( (v), (e),
(Unit,
),
@@ -823,9 +735,9 @@ namespace {
TRACE_FUNCTION;
serialise_generics(item.m_params);
- write_tag( static_cast<int>(item.m_repr) );
+ m_out.write_tag( static_cast<int>(item.m_repr) );
- write_tag( item.m_data.tag() );
+ m_out.write_tag( item.m_data.tag() );
TU_MATCHA( (item.m_data), (e),
(Unit,
),
@@ -841,15 +753,15 @@ namespace {
{
TRACE_FUNCTION_F("_trait:");
serialise_generics(item.m_params);
- //write_string(item.m_lifetime); // TODO: Better type for lifetime
+ //m_out.write_string(item.m_lifetime); // TODO: Better type for lifetime
serialise_vec( item.m_parent_traits );
- write_bool( item.m_is_marker );
+ m_out.write_bool( item.m_is_marker );
serialise_strmap( item.m_types );
serialise_strmap( item.m_values );
}
void serialise(const ::HIR::TraitValueItem& tvi)
{
- write_tag( tvi.tag() );
+ m_out.write_tag( tvi.tag() );
TU_MATCHA( (tvi), (e),
(Constant,
DEBUG("Constant");
@@ -867,8 +779,8 @@ namespace {
}
void serialise(const ::HIR::AssociatedType& at)
{
- write_bool(at.is_sized);
- //write_string(at.m_lifetime_bound); // TODO: better type for lifetime
+ m_out.write_bool(at.is_sized);
+ //m_out.write_string(at.m_lifetime_bound); // TODO: better type for lifetime
serialise_vec(at.m_trait_bounds);
serialise_type(at.m_default);
}
@@ -877,7 +789,7 @@ namespace {
void HIR_Serialise(const ::std::string& filename, const ::HIR::Crate& crate)
{
- ::std::ofstream out(filename);
+ ::HIR::serialise::Writer out { filename };
HirSerialiser s { out };
s.serialise_crate(crate);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-05 06:29:48 +0000