HIR - Ticking along - Generics hacked up, on to patterns

4 files changed, 96 insertions, 9 deletions

diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index fa10c344..82b7e489 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -39,7 +39,10 @@
     
     if( gp.ty_params().size() > 0 )
     {
-        throw ::std::runtime_error("TODO: LowerHIR_GenericParams - types");
+        for(const auto& tp : gp.ty_params())
+        {
+            rv.m_types.push_back({ tp.name(), LowerHIR_Type(tp.get_default()) });
+        }
     }
     if( gp.lft_params().size() > 0 )
     {
@@ -239,8 +242,9 @@
         return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_TraitObject( mv$(v) ) );
         ),
     (Function,
-        ::HIR::FunctionType f;
-        return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_Function( mv$(f) ) );
+        TODO(ty.span(), "Function types");
+        //::HIR::FunctionType f;
+        //return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_Function( mv$(f) ) );
         ),
     (Generic,
         return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_Generic({ e.name, 0 }) );
@@ -296,7 +300,18 @@
 }
 ::HIR::Function LowerHIR_Function(const ::AST::Function& f)
 {
-    throw ::std::runtime_error("TODO: LowerHIR_Function");
+    ::std::vector< ::std::pair< ::HIR::Pattern, ::HIR::TypeRef > >    args;
+    for(const auto& arg : f.args())
+        args.push_back( ::std::make_pair( LowerHIR_Pattern(arg.first), LowerHIR_Type(arg.second) ) );
+    
+    // TODO: ABI and unsafety/constness
+    return ::HIR::Function {
+        "rust", false, false,
+        LowerHIR_GenericParams(f.params()),
+        mv$(args),
+        LowerHIR_Type( f.rettype() ),
+        LowerHIR_Expr( f.code() )
+        };
 }
 
 void _add_mod_ns_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::HIR::TypeItem ti) {
diff --git a/src/hir/generic_params.hpp b/src/hir/generic_params.hpp
new file mode 100644
index 00000000..5323f26d
--- /dev/null
+++ b/src/hir/generic_params.hpp
@@ -0,0 +1,26 @@
+/*
+ */
+#pragma once
+
+namespace HIR {
+
+struct TypeParamDef
+{
+    ::std::string   m_name;
+    ::HIR::TypeRef  m_default;
+};
+
+struct GenericBound
+{
+};
+
+struct GenericParams
+{
+    ::std::vector<TypeParamDef>   m_types;
+    ::std::vector< ::std::string>   m_lifetimes;
+    
+    ::std::vector<GenericBound>    m_bounds;
+};
+
+}   // namespace HIR
+
diff --git a/src/hir/hir.hpp b/src/hir/hir.hpp
index 5592cd9b..0756b8b0 100644
--- a/src/hir/hir.hpp
+++ b/src/hir/hir.hpp
@@ -18,6 +18,7 @@
 #include <hir/path.hpp>
 #include <hir/pattern.hpp>
 #include <hir/expr_ptr.hpp>
+#include <hir/generic_params.hpp>
 
 namespace HIR {
 
@@ -38,10 +39,6 @@ struct VisEnt
 };
 
 
-struct GenericParams
-{
-};
-
 // --------------------------------------------------------------------
 // Type structures
 // --------------------------------------------------------------------
@@ -62,6 +59,10 @@ struct Constant
 };
 struct Function
 {
+    ::std::string   m_abi;
+    bool    m_unsafe;
+    bool    m_const;
+    
     GenericParams   m_params;
     
     ::std::vector< ::std::pair< Pattern, TypeRef > >    m_args;
diff --git a/src/hir/pattern.hpp b/src/hir/pattern.hpp
index 4fa262ce..2ff0a0d2 100644
--- a/src/hir/pattern.hpp
+++ b/src/hir/pattern.hpp
@@ -2,9 +2,54 @@
  */
 #pragma once
 
+#include <memory>
+#include <vector>
+#include <tagged_union.hpp>
+#include <hir/path.hpp>
+#include <hir/type.hpp>
+
 namespace HIR {
 
-class Pattern {
+struct PatternBinding
+{
+    ::std::string   m_name;
+    unsigned int    m_slot;
+    
+    bool is_valid() const { return m_name == ""; }
+};
+
+struct Pattern
+{
+    TAGGED_UNION(Value, String,
+        (Integer, struct {
+            enum ::HIR::CoreType type;
+            uint64_t value; // Signed numbers are encoded as 2's complement
+            }),
+        (String, ::std::string),
+        (Named, Path)
+        );
+
+    TAGGED_UNION(Data, Any,
+        (Any,       struct { } ),
+        (Box,       struct { ::std::unique_ptr<Pattern> sub; }),
+        (Ref,       struct { bool mut; ::std::unique_ptr<Pattern> sub; } ),
+        (Value,     struct { Value val; } ),
+        (Range,     struct { Value start; Value end; } ),
+        (Tuple,     struct { ::std::vector<Pattern> sub_patterns; } ),
+        (StructTuple, struct { GenericPath path; ::std::vector<Pattern> sub_patterns; } ),
+        (Struct,    struct { GenericPath path; ::std::vector< ::std::pair< ::std::string, Pattern> > sub_patterns; } ),
+        (Slice,     struct {
+            ::std::vector<Pattern> leading;
+            } ),
+        (SplitSlice, struct {
+            ::std::vector<Pattern> leading;
+            PatternBinding extra_bind;
+            ::std::vector<Pattern> trailing;
+            } )
+        );
+
+    PatternBinding  m_binding;
+    Data    m_data;
 };
 
 }