1 files changed, 56 insertions, 18 deletions

diff --git a/src/ast/generics.hpp b/src/ast/generics.hpp
index bc14202e..c222044c 100644
--- a/src/ast/generics.hpp
+++ b/src/ast/generics.hpp
@@ -14,49 +14,86 @@ namespace AST {
 
 class TypeParam
 {
+    ::AST::AttributeList    m_attrs;
+    Span    m_span;
+    // TODO: use an Ident?
     ::std::string   m_name;
     ::TypeRef m_default;
 public:
     TypeParam(TypeParam&& x) = default;
     TypeParam& operator=(TypeParam&& x) = default;
-    TypeParam(const TypeParam& x):
-        m_name(x.m_name),
-        m_default(x.m_default.clone())
-    {}
-    //TypeParam(): m_name("") {}
-    TypeParam(::std::string name):
+    explicit TypeParam(const TypeParam& x):
+        m_attrs( x.m_attrs ),
+        m_span( x.m_span ),
+        m_name( x.m_name ),
+        m_default( x.m_default.clone() )
+    {
+    }
+
+    TypeParam(Span sp, ::AST::AttributeList attrs, ::std::string name):
+        m_attrs( ::std::move(attrs) ),
+        m_span( ::std::move(sp) ),
         m_name( ::std::move(name) ),
-        m_default( Span() )
+        m_default(m_span)
     {}
+
     void setDefault(TypeRef type) {
         assert(m_default.is_wildcard());
         m_default = ::std::move(type);
     }
 
-    const ::std::string&    name() const { return m_name; }
+    const ::AST::AttributeList& attrs() const { return m_attrs; }
+    const Span& span() const { return m_span; }
+    const ::std::string& name() const { return m_name; }
 
     const TypeRef& get_default() const { return m_default; }
           TypeRef& get_default()       { return m_default; }
 
     friend ::std::ostream& operator<<(::std::ostream& os, const TypeParam& tp);
 };
+class LifetimeParam
+{
+    ::AST::AttributeList    m_attrs;
+    Span    m_span;
+    Ident   m_name;
+public:
+    LifetimeParam(Span sp, ::AST::AttributeList attrs, Ident name):
+        m_attrs( ::std::move(attrs) ),
+        m_span( ::std::move(sp) ),
+        m_name( ::std::move(name) )
+    {
+    }
+    LifetimeParam(LifetimeParam&&) = default;
+    LifetimeParam& operator=(LifetimeParam&&) = default;
+    explicit LifetimeParam(const LifetimeParam&) = default;
+
+    const ::AST::AttributeList& attrs() const { return m_attrs; }
+    const Span& span() const { return m_span; }
+    const Ident& name() const { return m_name; }
+
+    friend ::std::ostream& operator<<(::std::ostream& os, const LifetimeParam& p);
+};
+
+// HigherRankedBounds is defined in `types.hpp`
 
-TAGGED_UNION_EX( GenericBound, (), Lifetime,
+TAGGED_UNION_EX( GenericBound, (), None,
     (
+    (None, struct{}),
     // Lifetime bound: 'test must be valid for 'bound
     (Lifetime, struct {
-        ::std::string   test;
-        ::std::string   bound;
+        LifetimeRef test;
+        LifetimeRef bound;
         }),
     // Type lifetime bound
     (TypeLifetime, struct {
         TypeRef type;
-        ::std::string   bound;
+        LifetimeRef bound;
         }),
     // Standard trait bound: "Type: [for<'a>] Trait"
     (IsTrait, struct {
+        HigherRankedBounds  outer_hrbs;
         TypeRef type;
-        ::std::vector< ::std::string>   hrls; // Higher-ranked lifetimes
+        HigherRankedBounds  inner_hrbs;
         AST::Path   trait;
         }),
     // Removed trait bound: "Type: ?Trait"
@@ -84,9 +121,10 @@ TAGGED_UNION_EX( GenericBound, (), Lifetime,
 
         GenericBound clone() const {
             TU_MATCH(GenericBound, ( (*this) ), (ent),
+            (None, return make_None({}); ),
             (Lifetime,     return make_Lifetime({ent.test, ent.bound});     ),
             (TypeLifetime, return make_TypeLifetime({ent.type.clone(), ent.bound}); ),
-            (IsTrait,    return make_IsTrait({ent.type.clone(), ent.hrls, ent.trait}); ),
+            (IsTrait,    return make_IsTrait({ent.outer_hrbs, ent.type.clone(), ent.inner_hrbs, ent.trait}); ),
             (MaybeTrait, return make_MaybeTrait({ent.type.clone(), ent.trait}); ),
             (NotTrait,   return make_NotTrait({ent.type.clone(), ent.trait}); ),
             (Equality,   return make_Equality({ent.type.clone(), ent.replacement.clone()}); )
@@ -101,7 +139,7 @@ TAGGED_UNION_EX( GenericBound, (), Lifetime,
 class GenericParams
 {
     ::std::vector<TypeParam>    m_type_params;
-    ::std::vector< ::std::string > m_lifetime_params;
+    ::std::vector<LifetimeParam>    m_lifetime_params;
     ::std::vector<GenericBound>    m_bounds;
 public:
     GenericParams() {}
@@ -112,7 +150,7 @@ public:
     GenericParams clone() const {
         GenericParams   rv;
         rv.m_type_params = ::std::vector<TypeParam>( m_type_params );   // Copy-constructable
-        rv.m_lifetime_params = m_lifetime_params;
+        rv.m_lifetime_params = ::std::vector<LifetimeParam>(m_lifetime_params);
         rv.m_bounds.reserve( m_bounds.size() );
         for(auto& e: m_bounds)
             rv.m_bounds.push_back( e.clone() );
@@ -121,12 +159,12 @@ public:
 
     const ::std::vector<TypeParam>& ty_params() const { return m_type_params; }
           ::std::vector<TypeParam>& ty_params()       { return m_type_params; }
-    const ::std::vector< ::std::string>&    lft_params() const { return m_lifetime_params; }
+    const ::std::vector<LifetimeParam>& lft_params() const { return m_lifetime_params; }
     const ::std::vector<GenericBound>& bounds() const { return m_bounds; }
           ::std::vector<GenericBound>& bounds()       { return m_bounds; }
 
     void add_ty_param(TypeParam param) { m_type_params.push_back( ::std::move(param) ); }
-    void add_lft_param(::std::string name) { m_lifetime_params.push_back( ::std::move(name) ); }
+    void add_lft_param(LifetimeParam lft) { m_lifetime_params.push_back( ::std::move(lft) ); }
     void add_bound(GenericBound bound) {
         m_bounds.push_back( ::std::move(bound) );
     }