1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
/*
* MRustC - Rust Compiler
* - By John Hodge (Mutabah/thePowersGang)
*
* mir/check.cpp
* - MIR Correctness validation
*/
#include "main_bindings.hpp"
#include "mir.hpp"
#include <hir/visitor.hpp>
#include <hir_typeck/static.hpp>
void MIR_Validate(const StaticTraitResolve& resolve, const ::MIR::Function& fcn)
{
}
namespace {
// TODO: Create visitor that handles setting up a StaticTraitResolve?
class OuterVisitor:
public ::HIR::Visitor
{
StaticTraitResolve m_resolve;
public:
OuterVisitor(const ::HIR::Crate& crate):
m_resolve(crate)
{}
// NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
void visit_expr(::HIR::ExprPtr& exp) override {
BUG(Span(), "visit_expr hit in OuterVisitor");
}
void visit_type(::HIR::TypeRef& ty) override
{
TU_IFLET(::HIR::TypeRef::Data, ty.m_data, Array, e,
this->visit_type( *e.inner );
DEBUG("Array size " << ty);
if( e.size ) {
MIR_Validate(m_resolve, *e.size.m_mir);
}
)
else {
::HIR::Visitor::visit_type(ty);
}
}
// ------
// Code-containing items
// ------
void visit_function(::HIR::ItemPath p, ::HIR::Function& item) override {
auto _ = this->m_resolve.set_item_generics(item.m_params);
if( item.m_code ) {
DEBUG("Function code " << p);
MIR_Validate(m_resolve, *item.m_code.m_mir);
}
}
void visit_static(::HIR::ItemPath p, ::HIR::Static& item) override {
if( item.m_value ) {
DEBUG("`static` value " << p);
MIR_Validate(m_resolve, *item.m_value.m_mir);
}
}
void visit_constant(::HIR::ItemPath p, ::HIR::Constant& item) override {
if( item.m_value ) {
DEBUG("`const` value " << p);
MIR_Validate(m_resolve, *item.m_value.m_mir);
}
}
void visit_enum(::HIR::ItemPath p, ::HIR::Enum& item) override {
auto _ = this->m_resolve.set_item_generics(item.m_params);
for(auto& var : item.m_variants)
{
TU_IFLET(::HIR::Enum::Variant, var.second, Value, e,
MIR_Validate(m_resolve, *e.m_mir);
)
}
}
// Boilerplate
void visit_trait(::HIR::ItemPath p, ::HIR::Trait& item) override {
auto _ = this->m_resolve.set_impl_generics(item.m_params);
::HIR::Visitor::visit_trait(p, item);
}
void visit_type_impl(::HIR::TypeImpl& impl) override {
auto _ = this->m_resolve.set_impl_generics(impl.m_params);
::HIR::Visitor::visit_type_impl(impl);
}
void visit_trait_impl(const ::HIR::SimplePath& trait_path, ::HIR::TraitImpl& impl) override {
auto _ = this->m_resolve.set_impl_generics(impl.m_params);
::HIR::Visitor::visit_trait_impl(trait_path, impl);
}
};
}
// --------------------------------------------------------------------
void MIR_CheckCrate(/*const*/ ::HIR::Crate& crate)
{
OuterVisitor ov(crate);
ov.visit_crate( crate );
}
|
