diff options
| -rw-r--r-- | Makefile | 1 | ||||
| -rw-r--r-- | src/hir/expr.cpp | 8 | ||||
| -rw-r--r-- | src/hir/from_ast.cpp | 7 | ||||
| -rw-r--r-- | src/hir/from_ast_expr.cpp | 8 | ||||
| -rw-r--r-- | src/hir/hir.hpp | 4 | ||||
| -rw-r--r-- | src/hir/visitor.cpp | 378 | ||||
| -rw-r--r-- | src/hir/visitor.hpp | 46 | ||||
| -rw-r--r-- | src/hir_conv/expand_type.cpp | 281 | ||||
| -rw-r--r-- | src/main.cpp | 3 |
9 files changed, 512 insertions, 224 deletions
@@ -41,6 +41,7 @@ OBJ += resolve/use.o resolve/index.o resolve/absolute.o OBJ += hir/from_ast.o hir/from_ast_expr.o OBJ += hir/crate_ptr.o hir/type_ptr.o hir/expr_ptr.o OBJ += hir/type.o hir/path.o hir/expr.o +OBJ += hir/visitor.o OBJ += hir_conv/expand_type.o hir_conv/constant_evaluation.o OBJ += dump_as_rust.o diff --git a/src/hir/expr.cpp b/src/hir/expr.cpp index efa02dfc..bb3bf0eb 100644 --- a/src/hir/expr.cpp +++ b/src/hir/expr.cpp @@ -9,10 +9,13 @@ #define DEF_VISIT(nt, n, code) void ::HIR::nt::visit(ExprVisitor& nv) { nv.visit(*this); } void ::HIR::ExprVisitorDef::visit(::HIR::nt& n) { code } DEF_VISIT(ExprNode_Block, node, - for(const auto& subnode : node.m_nodes) + for(const auto& subnode : node.m_nodes) { + assert(subnode); subnode->visit(*this); + } ) DEF_VISIT(ExprNode_Return, node, + assert(node.m_value); node.m_value->visit(*this); ) DEF_VISIT(ExprNode_Let, node, @@ -21,15 +24,18 @@ DEF_VISIT(ExprNode_Let, node, } ) DEF_VISIT(ExprNode_Loop, node, + assert(node.m_code); node.m_code->visit(*this); ) DEF_VISIT(ExprNode_LoopControl, , ) DEF_VISIT(ExprNode_Match, node, + assert(node.m_value); node.m_value->visit(*this); for(auto& arm : node.m_arms) { if( arm.m_cond ) arm.m_cond->visit(*this); + assert(arm.m_code); arm.m_code->visit(*this); } ) diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp index 46a49e75..2d5339ac 100644 --- a/src/hir/from_ast.cpp +++ b/src/hir/from_ast.cpp @@ -786,8 +786,8 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod, ::HIR::Crate& hir_crat else { ::std::map< ::std::string, ::HIR::Function> methods; - ::std::map< ::std::string, ::HIR::Constant> constants; - ::std::map< ::std::string, ::HIR::TypeAlias> types; + ::std::map< ::std::string, ::HIR::ExprPtr> constants; + ::std::map< ::std::string, ::HIR::TypeRef> types; for(const auto& item : impl.items()) { @@ -795,8 +795,9 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod, ::HIR::Crate& hir_crat ( ERROR(Span(), E0000, "Unexpected item type in trait impl"); ), + // TODO: Associated constants (Type, - types.insert( ::std::make_pair(item.name, LowerHIR_TypeAlias(e)) ); + types.insert( ::std::make_pair(item.name, LowerHIR_Type(e.type())) ); ), (Function, methods.insert( ::std::make_pair(item.name, LowerHIR_Function(e)) ); diff --git a/src/hir/from_ast_expr.cpp b/src/hir/from_ast_expr.cpp index ffcb82ce..d9982da9 100644 --- a/src/hir/from_ast_expr.cpp +++ b/src/hir/from_ast_expr.cpp @@ -28,6 +28,9 @@ struct LowerHIR_ExprNode_Visitor: if( n ) { rv->m_nodes.push_back( LowerHIR_ExprNode_Inner( *n ) ); } + else { + rv->m_nodes.push_back( ::HIR::ExprNodeP( new ::HIR::ExprNode_Tuple({}) ) ); + } } if( v.m_local_mod ) @@ -44,7 +47,10 @@ struct LowerHIR_ExprNode_Visitor: switch( v.m_type ) { case ::AST::ExprNode_Flow::RETURN: - m_rv.reset( new ::HIR::ExprNode_Return( LowerHIR_ExprNode_Inner_Opt(v.m_value.get()) ) ); + if( v.m_value ) + m_rv.reset( new ::HIR::ExprNode_Return( LowerHIR_ExprNode_Inner(*v.m_value) ) ); + else + m_rv.reset( new ::HIR::ExprNode_Return( ::HIR::ExprNodeP(new ::HIR::ExprNode_Tuple({})) ) ); break; case ::AST::ExprNode_Flow::CONTINUE: case ::AST::ExprNode_Flow::BREAK: diff --git a/src/hir/hir.hpp b/src/hir/hir.hpp index afb742cf..4236e8ac 100644 --- a/src/hir/hir.hpp +++ b/src/hir/hir.hpp @@ -207,8 +207,8 @@ public: ::HIR::TypeRef m_type; ::std::map< ::std::string, ::HIR::Function> m_methods; - ::std::map< ::std::string, ::HIR::Constant> m_constants; - ::std::map< ::std::string, ::HIR::TypeAlias> m_types; + ::std::map< ::std::string, ::HIR::ExprPtr> m_constants; + ::std::map< ::std::string, ::HIR::TypeRef> m_types; }; class MarkerImpl diff --git a/src/hir/visitor.cpp b/src/hir/visitor.cpp new file mode 100644 index 00000000..76bfda9c --- /dev/null +++ b/src/hir/visitor.cpp @@ -0,0 +1,378 @@ + +#include <hir/hir.hpp> +#include <hir/visitor.hpp> + +::HIR::Visitor::~Visitor() +{ +} + +void ::HIR::Visitor::visit_crate(::HIR::Crate& crate) +{ + this->visit_module( crate.m_root_module ); + + for( auto& ty_impl : crate.m_type_impls ) + { + this->visit_type_impl(ty_impl); + } + for( auto& impl : crate.m_trait_impls ) + { + this->visit_trait_impl(impl.second); + } + for( auto& impl : crate.m_marker_impls ) + { + this->visit_marker_impl(impl.second); + } +} + +void ::HIR::Visitor::visit_module(::HIR::Module& mod) +{ + for( auto& named : mod.m_mod_items ) + { + auto& item = named.second->ent; + TU_MATCH(::HIR::TypeItem, (item), (e), + (Import, ), + (Module, + this->visit_module(e); + ), + (TypeAlias, + this->visit_type_alias(e); + ), + (Enum, + this->visit_enum(e); + ), + (Struct, + this->visit_struct(e); + ), + (Trait, + this->visit_trait(e); + ) + ) + } + for( auto& named : mod.m_value_items ) + { + auto& item = named.second->ent; + TU_MATCH(::HIR::ValueItem, (item), (e), + (Import, ), + (Constant, + this->visit_constant(e); + ), + (Static, + this->visit_static(e); + ), + (StructConstant, + // Just a path + ), + (Function, + this->visit_function(e); + ), + (StructConstructor, + // Just a path + ) + ) + } +} + + +void ::HIR::Visitor::visit_type_impl(::HIR::TypeImpl& impl) +{ + this->visit_params(impl.m_params); + this->visit_type(impl.m_type); + + for(auto& method : impl.m_methods) { + this->visit_function(method.second); + } +} +void ::HIR::Visitor::visit_trait_impl(::HIR::TraitImpl& impl) +{ + this->visit_params(impl.m_params); + this->visit_path_params(impl.m_trait_args); + this->visit_type(impl.m_type); + + for(auto& ent : impl.m_methods) { + this->visit_function(ent.second); + } + for(auto& ent : impl.m_constants) { + this->visit_expr(ent.second); + } + for(auto& ent : impl.m_types) { + this->visit_type(ent.second); + } +} +void ::HIR::Visitor::visit_marker_impl(::HIR::MarkerImpl& impl) +{ + this->visit_params(impl.m_params); + this->visit_path_params(impl.m_trait_args); + this->visit_type(impl.m_type); +} + +void ::HIR::Visitor::visit_type_alias(::HIR::TypeAlias& item) +{ + this->visit_params(item.m_params); + this->visit_type(item.m_type); +} +void ::HIR::Visitor::visit_trait(::HIR::Trait& item) +{ + this->visit_params(item.m_params); + for(auto& par : item.m_parent_traits) { + this->visit_generic_path(par); + } + for(auto& i : item.m_types) { + this->visit_params(i.second.m_params); + this->visit_type(i.second.m_default); + } + for(auto& i : item.m_values) { + TU_MATCH(::HIR::TraitValueItem, (i.second), (e), + (None, ), + (Constant, + this->visit_constant(e); + ), + (Static, + this->visit_static(e); + ), + (Function, + this->visit_function(e); + ) + ) + } +} +void ::HIR::Visitor::visit_struct(::HIR::Struct& item) +{ + this->visit_params(item.m_params); + TU_MATCH(::HIR::Struct::Data, (item.m_data), (e), + (Unit, + ), + (Tuple, + for(auto& ty : e) { + this->visit_type(ty.ent); + } + ), + (Named, + for(auto& field : e) { + this->visit_type(field.second.ent); + } + ) + ) +} +void ::HIR::Visitor::visit_enum(::HIR::Enum& item) +{ + this->visit_params(item.m_params); + for(auto& var : item.m_variants) + { + TU_MATCH(::HIR::Enum::Variant, (var.second), (v), + (Unit, + ), + (Value, + this->visit_expr(v); + ), + (Tuple, + for(auto& ty : v) { + this->visit_type(ty); + } + ), + (Struct, + for(auto& field : v) { + this->visit_type(field.second); + } + ) + ) + } +} +void ::HIR::Visitor::visit_function(::HIR::Function& item) +{ + this->visit_params(item.m_params); + for(auto& arg : item.m_args) + { + this->visit_pattern(arg.first); + this->visit_type(arg.second); + } + this->visit_type(item.m_return); + this->visit_expr(item.m_code); +} +void ::HIR::Visitor::visit_static(::HIR::Static& item) +{ + this->visit_type(item.m_type); + this->visit_expr(item.m_value); +} +void ::HIR::Visitor::visit_constant(::HIR::Constant& item) +{ + this->visit_params(item.m_params); + this->visit_type(item.m_type); + this->visit_expr(item.m_value); +} + +void ::HIR::Visitor::visit_params(::HIR::GenericParams& params) +{ + for(auto& tps : params.m_types) + this->visit_type( tps.m_default ); + for(auto& bound : params.m_bounds ) + { + TU_MATCH(::HIR::GenericBound, (bound), (e), + (Lifetime, + ), + (TypeLifetime, + this->visit_type(e.type); + ), + (TraitBound, + this->visit_type(e.type); + this->visit_generic_path(e.trait.m_path); + ), + (TraitUnbound, + this->visit_type(e.type); + // typeof(e.trait) == SimplePath + ), + //(NotTrait, struct { + // ::HIR::TypeRef type; + // ::HIR::GenricPath trait; + // }), + (TypeEquality, + this->visit_type(e.type); + this->visit_type(e.other_type); + ) + ) + } +} +void ::HIR::Visitor::visit_type(::HIR::TypeRef& ty) +{ + TU_MATCH(::HIR::TypeRef::Data, (ty.m_data), (e), + (Infer, + ), + (Diverge, + ), + (Primitive, + ), + (Path, + this->visit_path(e); + ), + (Generic, + ), + (TraitObject, + for(auto& trait : e.m_traits) { + this->visit_generic_path(trait); + } + ), + (Array, + this->visit_type( *e.inner ); + this->visit_expr( e.size ); + ), + (Tuple, + for(auto& t : e) { + this->visit_type(t); + } + ), + (Borrow, + this->visit_type( *e.inner ); + ), + (Pointer, + this->visit_type( *e.inner ); + ), + (Function, + for(auto& t : e.m_arg_types) { + this->visit_type(t); + } + this->visit_type(*e.m_rettype); + ) + ) +} +void ::HIR::Visitor::visit_pattern(::HIR::Pattern& pat) +{ + TU_MATCH(::HIR::Pattern::Data, (pat.m_data), (e), + (Any, + ), + (Box, + this->visit_pattern( *e.sub ); + ), + (Ref, + this->visit_pattern( *e.sub ); + ), + (Tuple, + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp); + ), + (StructTuple, + this->visit_generic_path(e.path); + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp); + ), + (Struct, + this->visit_generic_path(e.path); + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp.second); + ), + // Refutable + (Value, + this->visit_pattern_val(e.val); + ), + (Range, + this->visit_pattern_val(e.start); + this->visit_pattern_val(e.end); + ), + (EnumTuple, + this->visit_generic_path(e.path); + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp); + ), + (EnumStruct, + this->visit_generic_path(e.path); + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp.second); + ), + (Slice, + for(auto& sp : e.sub_patterns) + this->visit_pattern(sp); + ), + (SplitSlice, + for(auto& sp : e.leading) + this->visit_pattern(sp); + for(auto& sp : e.trailing) + this->visit_pattern(sp); + ) + ) +} +void ::HIR::Visitor::visit_pattern_val(::HIR::Pattern::Value& val) +{ + TU_MATCH(::HIR::Pattern::Value, (val), (e), + (Integer, + ), + (String, + ), + (Named, + this->visit_path(e); + ) + ) +} +void ::HIR::Visitor::visit_path(::HIR::Path& p) +{ + TU_MATCH(::HIR::Path::Data, (p.m_data), (e), + (Generic, + this->visit_generic_path(e); + ), + (UfcsInherent, + this->visit_type(*e.type); + this->visit_path_params(e.params); + ), + (UfcsKnown, + this->visit_type(*e.type); + this->visit_generic_path(e.trait); + this->visit_path_params(e.params); + ), + (UfcsUnknown, + this->visit_type(*e.type); + this->visit_path_params(e.params); + ) + ) +} +void ::HIR::Visitor::visit_path_params(::HIR::PathParams& p) +{ + for( auto& ty : p.m_types ) + { + this->visit_type(ty); + } +} +void ::HIR::Visitor::visit_generic_path(::HIR::GenericPath& p) +{ + this->visit_path_params(p.m_params); +} +void ::HIR::Visitor::visit_expr(::HIR::ExprPtr& exp) +{ + // Do nothing, leave expression stuff for user +} diff --git a/src/hir/visitor.hpp b/src/hir/visitor.hpp new file mode 100644 index 00000000..814dac67 --- /dev/null +++ b/src/hir/visitor.hpp @@ -0,0 +1,46 @@ +/* + */ +#pragma once + +#include <hir/hir.hpp> + +namespace HIR { + +class Visitor +{ +public: + virtual ~Visitor(); + + virtual void visit_crate(::HIR::Crate& crate); + + virtual void visit_module(::HIR::Module& mod); + + virtual void visit_type_impl(::HIR::TypeImpl& impl); + virtual void visit_trait_impl(::HIR::TraitImpl& impl); + virtual void visit_marker_impl(::HIR::MarkerImpl& impl); + + // - Type Items + virtual void visit_type_alias(::HIR::TypeAlias& item); + virtual void visit_trait(::HIR::Trait& item); + virtual void visit_struct(::HIR::Struct& item); + virtual void visit_enum(::HIR::Enum& item); + // - Value Items + virtual void visit_function(::HIR::Function& item); + virtual void visit_static(::HIR::Static& item); + virtual void visit_constant(::HIR::Constant& item); + + // - Misc + virtual void visit_params(::HIR::GenericParams& params); + virtual void visit_pattern(::HIR::Pattern& pat); + virtual void visit_pattern_val(::HIR::Pattern::Value& val); + virtual void visit_type(::HIR::TypeRef& tr); + + virtual void visit_path(::HIR::Path& p); + virtual void visit_path_params(::HIR::PathParams& p); + virtual void visit_generic_path(::HIR::GenericPath& p); + + virtual void visit_expr(::HIR::ExprPtr& exp); +}; + +} // namespace HIR + diff --git a/src/hir_conv/expand_type.cpp b/src/hir_conv/expand_type.cpp index ac34f2a8..7e47b3a3 100644 --- a/src/hir_conv/expand_type.cpp +++ b/src/hir_conv/expand_type.cpp @@ -4,8 +4,7 @@ #include "main_bindings.hpp" #include <hir/hir.hpp> #include <hir/expr.hpp> - -void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty); +#include <hir/visitor.hpp> ::HIR::TypeRef ConvertHIR_ExpandAliases_GetExpansion(const ::HIR::Crate& crate, const ::HIR::Path& path) { @@ -58,232 +57,82 @@ void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty return ::HIR::TypeRef(); } -void ConvertHIR_ExpandAliases_PathParams(const ::HIR::Crate& crate, ::HIR::PathParams& p) +class Expander: + public ::HIR::Visitor { - for(auto& ty : p.m_types) - { - ConvertHIR_ExpandAliases_Type(crate, ty); - } -} -void ConvertHIR_ExpandAliases_Path(const ::HIR::Crate& crate, ::HIR::GenericPath& p) -{ - ConvertHIR_ExpandAliases_PathParams(crate, p.m_params); -} + const ::HIR::Crate& m_crate; -void ConvertHIR_ExpandAliases_Path(const ::HIR::Crate& crate, ::HIR::Path& p) -{ - TU_MATCH(::HIR::Path::Data, (p.m_data), (e), - (Generic, - ConvertHIR_ExpandAliases_Path(crate, e); - ), - (UfcsInherent, - ConvertHIR_ExpandAliases_Type(crate, *e.type); - ConvertHIR_ExpandAliases_PathParams(crate, e.params); - ), - (UfcsKnown, - ConvertHIR_ExpandAliases_Type(crate, *e.type); - ConvertHIR_ExpandAliases_Path(crate, e.trait); - ConvertHIR_ExpandAliases_PathParams(crate, e.params); - ), - (UfcsUnknown, - ConvertHIR_ExpandAliases_Type(crate, *e.type); - ConvertHIR_ExpandAliases_PathParams(crate, e.params); - ) - ) -} - -void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty) -{ - TU_MATCH(::HIR::TypeRef::Data, (ty.m_data), (e), - (Infer, - ), - (Diverge, - ), - (Primitive, - ), - (Path, - ConvertHIR_ExpandAliases_Path(crate, e); - - auto new_type = ConvertHIR_ExpandAliases_GetExpansion(crate, e); - if( ! new_type.m_data.is_Infer() ) { - DEBUG("Replacing " << ty << " with " << new_type); - } - ), - (Generic, - ), - (TraitObject, - for(auto& trait : e.m_traits) { - ConvertHIR_ExpandAliases_Path(crate, trait); - } - ), - (Array, - ConvertHIR_ExpandAliases_Type(crate, *e.inner); - // TODO: Expression? - ), - (Tuple, - for(auto& t : e) { - ConvertHIR_ExpandAliases_Type(crate, t); - } - ), - (Borrow, - ConvertHIR_ExpandAliases_Type(crate, *e.inner); - ), - (Pointer, - ConvertHIR_ExpandAliases_Type(crate, *e.inner); - ), - (Function, - for(auto& t : e.m_arg_types) { - ConvertHIR_ExpandAliases_Type(crate, t); - } - ConvertHIR_ExpandAliases_Type(crate, *e.m_rettype); - ) - ) -} -void ConvertHIR_ExpandAliases_Expr(const ::HIR::Crate& crate, ::HIR::ExprPtr& ep) -{ - struct Visitor: - public ::HIR::ExprVisitorDef - { - const ::HIR::Crate& crate; - - Visitor(const ::HIR::Crate& crate): - crate(crate) - {} - - void visit(::HIR::ExprNode_Let& node) override - { - ConvertHIR_ExpandAliases_Type(crate, node.m_type); - ::HIR::ExprVisitorDef::visit(node); - } - void visit(::HIR::ExprNode_Cast& node) override - { - ConvertHIR_ExpandAliases_Type(crate, node.m_type); - ::HIR::ExprVisitorDef::visit(node); - } - - void visit(::HIR::ExprNode_CallPath& node) override - { - ConvertHIR_ExpandAliases_Path(crate, node.m_path); - ::HIR::ExprVisitorDef::visit(node); - } - void visit(::HIR::ExprNode_CallMethod& node) override - { - ConvertHIR_ExpandAliases_PathParams(crate, node.m_params); - ::HIR::ExprVisitorDef::visit(node); - } - - void visit(::HIR::ExprNode_Closure& node) override - { - ConvertHIR_ExpandAliases_Type(crate, node.m_return); - for(auto& arg : node.m_args) - ConvertHIR_ExpandAliases_Type(crate, arg.second); - ::HIR::ExprVisitorDef::visit(node); - } - }; +public: + Expander(const ::HIR::Crate& crate): + m_crate(crate) + {} - if( &*ep != nullptr ) - { - Visitor v { crate }; - (*ep).visit(v); - } -} -void ConvertHIR_ExpandAliases_GenericParams(const ::HIR::Crate& crate, ::HIR::GenericParams& gp) -{ -} - -void ConvertHIR_ExpandAliases_Mod(const ::HIR::Crate& crate, ::HIR::Module& mod) -{ - for( auto& named : mod.m_mod_items ) + void visit_type(::HIR::TypeRef& ty) override { - auto& item = named.second->ent; - TU_MATCH(::HIR::TypeItem, (item), (e), - (Import, ), - (Module, - ConvertHIR_ExpandAliases_Mod(crate, e); - ), - (TypeAlias, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - ConvertHIR_ExpandAliases_Type(crate, e.m_type); - ), - (Enum, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - for(auto& var : e.m_variants) - { - TU_MATCH(::HIR::Enum::Variant, (var.second), (v), - (Unit, - ), - (Value, - ConvertHIR_ExpandAliases_Expr(crate, v); - ), - (Tuple, - for(auto& ty : v) { - ConvertHIR_ExpandAliases_Type(crate, ty); - } - ), - (Struct, - for(auto& field : v) { - ConvertHIR_ExpandAliases_Type(crate, field.second); - } - ) - ) + ::HIR::Visitor::visit_type(ty); + + TU_IFLET(::HIR::TypeRef::Data, (ty.m_data), Path, (e), + auto new_type = ConvertHIR_ExpandAliases_GetExpansion(m_crate, e); + if( ! new_type.m_data.is_Infer() ) { + DEBUG("Replacing " << ty << " with " << new_type); } - ), - (Struct, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - TU_MATCH(::HIR::Struct::Data, (e.m_data), (e2), - (Unit, - ), - (Tuple, - for(auto& ty : e2) { - ConvertHIR_ExpandAliases_Type(crate, ty.ent); - } - ), - (Named, - for(auto& field : e2) { - ConvertHIR_ExpandAliases_Type(crate, field.second.ent); - } - ) - ) - ), - (Trait, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - ) ) } - for( auto& named : mod.m_value_items ) + + void visit_expr(::HIR::ExprPtr& expr) override { - auto& item = named.second->ent; - TU_MATCH(::HIR::ValueItem, (item), (e), - (Import, ), - (Constant, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - ConvertHIR_ExpandAliases_Type(crate, e.m_type); - ConvertHIR_ExpandAliases_Expr(crate, e.m_value); - ), - (Static, - ConvertHIR_ExpandAliases_Type(crate, e.m_type); - ConvertHIR_ExpandAliases_Expr(crate, e.m_value); - ), - (StructConstant, - // Just a path - ), - (Function, - ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params); - for(auto& arg : e.m_args) + struct Visitor: + public ::HIR::ExprVisitorDef + { + Expander& upper_visitor; + + Visitor(Expander& uv): + upper_visitor(uv) + {} + + void visit(::HIR::ExprNode_Let& node) override { - ConvertHIR_ExpandAliases_Type(crate, arg.second); + upper_visitor.visit_type(node.m_type); + ::HIR::ExprVisitorDef::visit(node); } - ConvertHIR_ExpandAliases_Type(crate, e.m_return); - ConvertHIR_ExpandAliases_Expr(crate, e.m_code); - ), - (StructConstructor, - // Just a path - ) - ) + void visit(::HIR::ExprNode_Cast& node) override + { + upper_visitor.visit_type(node.m_type); + ::HIR::ExprVisitorDef::visit(node); + } + + void visit(::HIR::ExprNode_CallPath& node) override + { + upper_visitor.visit_path(node.m_path); + ::HIR::ExprVisitorDef::visit(node); + } + void visit(::HIR::ExprNode_CallMethod& node) override + { + upper_visitor.visit_path_params(node.m_params); + ::HIR::ExprVisitorDef::visit(node); + } + + void visit(::HIR::ExprNode_Closure& node) override + { + upper_visitor.visit_type(node.m_return); + for(auto& arg : node.m_args) { + upper_visitor.visit_pattern(arg.first); + upper_visitor.visit_type(arg.second); + } + ::HIR::ExprVisitorDef::visit(node); + } + }; + + if( &*expr != nullptr ) + { + Visitor v { *this }; + (*expr).visit(v); + } } -} +}; void ConvertHIR_ExpandAliases(::HIR::Crate& crate) { - ConvertHIR_ExpandAliases_Mod(crate, crate.m_root_module); + Expander exp { crate }; + exp.visit_crate( crate ); } diff --git a/src/main.cpp b/src/main.cpp index a02fbac6..b519f1fb 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -25,7 +25,8 @@ int g_debug_indent_level = 0; bool debug_enabled()
{
//return g_cur_phase != "Parse";
- return g_cur_phase != "Parse" && g_cur_phase != "Expand";
+ //return g_cur_phase != "Parse" && g_cur_phase != "Expand";
+ return g_cur_phase != "Parse" && g_cur_phase != "Expand" && g_cur_phase != "Resolve";;
}
::std::ostream& debug_output(int indent, const char* function)
{
|