Rename TypeParams to GenericParams

16 files changed, 100 insertions, 100 deletions

diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index f89cca98..7ab461d5 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -145,7 +145,7 @@ Impl Impl::make_concrete(const ::std::vector<TypeRef>& types) const
     

     GenericResolveClosure   resolver(m_def.params(), types);

     

-    Impl    ret( MetaItems(), TypeParams(), m_def.type(), m_def.trait() );

+    Impl    ret( MetaItems(), GenericParams(), m_def.type(), m_def.trait() );

     ret.m_def.trait().resolve_args( resolver );

     ret.m_def.type().resolve_args( resolver );

     

@@ -153,7 +153,7 @@ Impl Impl::make_concrete(const ::std::vector<TypeRef>& types) const
 /*

     for(const auto& fcn : m_functions)

     {

-        TypeParams  new_fcn_params = fcn.data.params();

+        GenericParams  new_fcn_params = fcn.data.params();

         for( auto& b : new_fcn_params.bounds() )

             b.type().resolve_args(resolver);

         TypeRef new_ret_type = fcn.data.rettype();

@@ -960,7 +960,7 @@ SERIALISE_TU(GenericBound, "GenericBound", ent,
         )

 )

 

-int TypeParams::find_name(const char* name) const

+int GenericParams::find_name(const char* name) const

 {

     for( unsigned int i = 0; i < m_type_params.size(); i ++ )

     {

@@ -971,11 +971,11 @@ int TypeParams::find_name(const char* name) const
     return -1;

 }

 

-bool TypeParams::check_params(Crate& crate, const ::std::vector<TypeRef>& types) const

+bool GenericParams::check_params(Crate& crate, const ::std::vector<TypeRef>& types) const

 {

     return check_params( crate, const_cast< ::std::vector<TypeRef>&>(types), false );

 }

-bool TypeParams::check_params(Crate& crate, ::std::vector<TypeRef>& types, bool allow_infer) const

+bool GenericParams::check_params(Crate& crate, ::std::vector<TypeRef>& types, bool allow_infer) const

 {

     // Check parameter counts

     if( types.size() > m_type_params.size() )

@@ -1044,11 +1044,11 @@ bool TypeParams::check_params(Crate& crate, ::std::vector<TypeRef>& types, bool
     return true;

 }

 

-::std::ostream& operator<<(::std::ostream& os, const TypeParams& tps)

+::std::ostream& operator<<(::std::ostream& os, const GenericParams& tps)

 {

     return os << "<" << tps.m_lifetime_params << "," << tps.m_type_params << "> where {" << tps.m_bounds << "}";

 }

-SERIALISE_TYPE_S(TypeParams, {

+SERIALISE_TYPE_S(GenericParams, {

     s.item(m_type_params);

     s.item(m_lifetime_params);

     s.item(m_bounds);

diff --git a/src/ast/ast.hpp b/src/ast/ast.hpp
index 74f4b36f..62eeff7c 100644
--- a/src/ast/ast.hpp
+++ b/src/ast/ast.hpp
@@ -110,26 +110,26 @@ TAGGED_UNION_EX( GenericBound, (: public Serialisable), Lifetime,
 

 ::std::ostream& operator<<(::std::ostream& os, const GenericBound& x);

 

-class TypeParams:

+class GenericParams:

     public Serialisable

 {

     ::std::vector<TypeParam>    m_type_params;

     ::std::vector< ::std::string > m_lifetime_params;

     ::std::vector<GenericBound>    m_bounds;

 public:

-    TypeParams() {}

-    TypeParams(TypeParams&& x) noexcept:

+    GenericParams() {}

+    GenericParams(GenericParams&& x) noexcept:

         m_type_params( mv$(x.m_type_params) ),

         m_lifetime_params( mv$(x.m_lifetime_params) ),

         m_bounds( mv$(x.m_bounds) )

     {}

-    TypeParams& operator=(TypeParams&& x) {

+    GenericParams& operator=(GenericParams&& x) {

         m_type_params = mv$(x.m_type_params);

         m_lifetime_params = mv$(x.m_lifetime_params);

         m_bounds = mv$(x.m_bounds);

         return *this;

     }

-    TypeParams(const TypeParams& x):

+    GenericParams(const GenericParams& x):

         m_type_params(x.m_type_params),

         m_lifetime_params(x.m_lifetime_params),

         m_bounds()

@@ -155,7 +155,7 @@ public:
     bool check_params(Crate& crate, const ::std::vector<TypeRef>& types) const;

     bool check_params(Crate& crate, ::std::vector<TypeRef>& types, bool allow_infer) const;

     

-    friend ::std::ostream& operator<<(::std::ostream& os, const TypeParams& tp);

+    friend ::std::ostream& operator<<(::std::ostream& os, const GenericParams& tp);

     SERIALISABLE_PROTOTYPES();

 };

 

@@ -292,21 +292,21 @@ class TypeAlias:
     public Serialisable

 {

     MetaItems   m_attrs;

-    TypeParams  m_params;

+    GenericParams  m_params;

     TypeRef m_type;

 public:

     TypeAlias() {}

-    TypeAlias(MetaItems attrs, TypeParams params, TypeRef type):

+    TypeAlias(MetaItems attrs, GenericParams params, TypeRef type):

         m_attrs( move(attrs) ),

         m_params( move(params) ),

         m_type( move(type) )

     {}

     

     const MetaItems& attrs() const { return m_attrs; }

-    const TypeParams& params() const { return m_params; }

+    const GenericParams& params() const { return m_params; }

     const TypeRef& type() const { return m_type; }

     

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     TypeRef& type() { return m_type; }

     

     SERIALISABLE_PROTOTYPES();

@@ -358,7 +358,7 @@ public:
 private:

     MetaItems   m_attrs;

     ::std::string   m_lifetime;

-    TypeParams  m_params;

+    GenericParams  m_params;

     Expr    m_code;

     TypeRef m_rettype;

     Arglist m_args;

@@ -367,7 +367,7 @@ public:
     {}

     Function(const Function&) = delete;

     Function(Function&&) noexcept = default;

-    Function(MetaItems attrs, TypeParams params, TypeRef ret_type, Arglist args):

+    Function(MetaItems attrs, GenericParams params, TypeRef ret_type, Arglist args):

         m_attrs( move(attrs) ),

         m_params( move(params) ),

         m_rettype( move(ret_type) ),

@@ -379,12 +379,12 @@ public:
     void set_self_lifetime(::std::string s) { m_lifetime = s; }

     

     const MetaItems& attrs() const { return m_attrs; }

-    const TypeParams& params() const { return m_params; }

+    const GenericParams& params() const { return m_params; }

     const Expr& code() const { return m_code; }

     const TypeRef& rettype() const { return m_rettype; }

     const Arglist& args() const { return m_args; }

     

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     Expr& code() { return m_code; }

     TypeRef& rettype() { return m_rettype; }

     Arglist& args() { return m_args; }

@@ -396,13 +396,13 @@ class Trait:
     public Serialisable

 {

     MetaItems   m_attrs;

-    TypeParams  m_params;

+    GenericParams  m_params;

     ::std::vector<AST::Path>    m_supertraits;

     ItemList<TypeAlias> m_types;

     ItemList<Function>  m_functions;

 public:

     Trait() {}

-    Trait(MetaItems attrs, TypeParams params, ::std::vector<Path> supertraits):

+    Trait(MetaItems attrs, GenericParams params, ::std::vector<Path> supertraits):

         m_attrs( mv$(attrs) ),

         m_params( mv$(params) ),

         m_supertraits( mv$(supertraits) )

@@ -410,18 +410,18 @@ public:
     }

     

     const MetaItems& attrs() const { return m_attrs; }

-    const TypeParams& params() const { return m_params; }

+    const GenericParams& params() const { return m_params; }

     const ::std::vector<Path>& supertraits() const { return m_supertraits; }

     const ItemList<Function>& functions() const { return m_functions; }

     const ItemList<TypeAlias>& types() const { return m_types; }

 

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     ::std::vector<Path>& supertraits() { return m_supertraits; }

     ItemList<Function>& functions() { return m_functions; }

     ItemList<TypeAlias>& types() { return m_types; }

     

     void add_type(::std::string name, TypeRef type) {

-        m_types.push_back( Item<TypeAlias>(move(name), TypeAlias(MetaItems(), TypeParams(), move(type)), true) );

+        m_types.push_back( Item<TypeAlias>(move(name), TypeAlias(MetaItems(), GenericParams(), move(type)), true) );

     }

     void add_function(::std::string name, Function fcn) {

         m_functions.push_back( Item<Function>(::std::move(name), ::std::move(fcn), true) );

@@ -485,21 +485,21 @@ class Enum:
     public Serialisable

 {

     MetaItems   m_attrs;

-    TypeParams    m_params;

+    GenericParams    m_params;

     ::std::vector<EnumVariant>   m_variants;

 public:

     Enum() {}

-    Enum( MetaItems attrs, TypeParams params, ::std::vector<EnumVariant> variants ):

+    Enum( MetaItems attrs, GenericParams params, ::std::vector<EnumVariant> variants ):

         m_attrs( move(attrs) ),

         m_params( move(params) ),

         m_variants( move(variants) )

     {}

     

     const MetaItems& attrs() const { return m_attrs; }

-    const TypeParams& params() const { return m_params; }

+    const GenericParams& params() const { return m_params; }

     const ::std::vector<EnumVariant>& variants() const { return m_variants; }

     

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     ::std::vector<EnumVariant>& variants() { return m_variants; }

     

     SERIALISABLE_PROTOTYPES();

@@ -509,22 +509,22 @@ class Struct:
     public Serialisable

 {

     MetaItems   m_attrs;

-    TypeParams    m_params;

+    GenericParams    m_params;

     ::std::vector<StructItem>   m_fields;

 public:

     Struct() {}

-    Struct( MetaItems attrs, TypeParams params, ::std::vector<StructItem> fields ):

+    Struct( MetaItems attrs, GenericParams params, ::std::vector<StructItem> fields ):

         m_attrs( move(attrs) ),

         m_params( move(params) ),

         m_fields( move(fields) )

     {}

     

     const MetaItems&    attrs()  const { return m_attrs; }

-    const TypeParams&   params() const { return m_params; }

+    const GenericParams&   params() const { return m_params; }

     const ::std::vector<StructItem>& fields() const { return m_fields; }

     

     MetaItems&  attrs()  { return m_attrs; }

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     ::std::vector<StructItem>& fields() { return m_fields; }

     

     TypeRef get_field_type(const char *name, const ::std::vector<TypeRef>& args);

@@ -536,13 +536,13 @@ class ImplDef:
     public Serialisable

 {

     MetaItems   m_attrs;

-    TypeParams  m_params;

+    GenericParams  m_params;

     Path    m_trait;

     TypeRef m_type;

 public:

     ImplDef() {}

     ImplDef(ImplDef&&) noexcept = default;

-    ImplDef(MetaItems attrs, TypeParams params, Path trait_type, TypeRef impl_type):

+    ImplDef(MetaItems attrs, GenericParams params, Path trait_type, TypeRef impl_type):

         m_attrs( move(attrs) ),

         m_params( move(params) ),

         m_trait( move(trait_type) ),

@@ -551,11 +551,11 @@ public:
     

     // Accessors

     const MetaItems& attrs() const { return m_attrs; }

-    const TypeParams& params() const { return m_params; }

+    const GenericParams& params() const { return m_params; }

     const Path& trait() const { return m_trait; }

     const TypeRef& type() const { return m_type; }

 

-    TypeParams& params() { return m_params; }

+    GenericParams& params() { return m_params; }

     Path& trait() { return m_trait; }

     TypeRef& type() { return m_type; }

     

@@ -578,7 +578,7 @@ class Impl:
 public:

     Impl() {}

     Impl(Impl&&) noexcept = default;

-    Impl(MetaItems attrs, TypeParams params, TypeRef impl_type, Path trait_type):

+    Impl(MetaItems attrs, GenericParams params, TypeRef impl_type, Path trait_type):

         m_def( move(attrs), move(params), move(trait_type), move(impl_type) )

     {}

 

@@ -921,10 +921,10 @@ public:
 

 class GenericResolveClosure

 {

-    const ::AST::TypeParams&  m_params;

+    const ::AST::GenericParams&  m_params;

     const ::std::vector<TypeRef>&   m_args;

 public:

-    GenericResolveClosure(const AST::TypeParams& params, const ::std::vector<TypeRef>& args):

+    GenericResolveClosure(const AST::GenericParams& params, const ::std::vector<TypeRef>& args):

         m_params(params),

         m_args(args)

     {}

diff --git a/src/ast/path.cpp b/src/ast/path.cpp
index 516cebbc..df5109c9 100644
--- a/src/ast/path.cpp
+++ b/src/ast/path.cpp
@@ -136,7 +136,7 @@ AST::Path::Path(const Path& x):
 }
 
 /*
-void Path::check_param_counts(const TypeParams& params, bool expect_params, PathNode& node)
+void Path::check_param_counts(const GenericParams& params, bool expect_params, PathNode& node)
 {
     if( !expect_params )
     {
diff --git a/src/ast/path.hpp b/src/ast/path.hpp
index 4f019b08..1d627a87 100644
--- a/src/ast/path.hpp
+++ b/src/ast/path.hpp
@@ -18,7 +18,7 @@ class TypeRef;
 
 namespace AST {
 
-class TypeParams;
+class GenericParams;
 class Crate;
 class Module;
 class TypeAlias;
@@ -326,7 +326,7 @@ private:
     static void match_args_nl(const ::std::vector<PathNode>& nodes_a, const ::std::vector<PathNode>& nodes_b, ::std::function<void(const char*,const TypeRef&)> fcn);
     static int node_lists_equal_no_generic(const ::std::vector<PathNode>& nodes_a, const ::std::vector<PathNode>& nodes_b);
     
-    void check_param_counts(const TypeParams& params, bool expect_params, PathNode& node);
+    void check_param_counts(const GenericParams& params, bool expect_params, PathNode& node);
 public:
     void bind_module(const Module& mod);
     void bind_enum(const Enum& ent, const ::std::vector<TypeRef>& args={});
diff --git a/src/ast/provided_module.cpp b/src/ast/provided_module.cpp
index fc006020..8d32fb96 100644
--- a/src/ast/provided_module.cpp
+++ b/src/ast/provided_module.cpp
@@ -12,7 +12,7 @@ void AST_InitProvidedModule()
 {
     // "struct str([u8])"
     g_compiler_module.add_struct(true, "str",
-        AST::Struct( AST::MetaItems(), AST::TypeParams(), ::std::vector<AST::StructItem> {
+        AST::Struct( AST::MetaItems(), AST::GenericParams(), ::std::vector<AST::StructItem> {
             AST::StructItem("", TypeRef(TypeRef::TagUnsizedArray(), TypeRef(CORETYPE_U8)), false),
         }));
     
@@ -31,7 +31,7 @@ void AST_InitProvidedModule_Impls()
     }
     
     #define impl(trait, type) \
-        g_compiler_module.add_impl(AST::Impl(AST::MetaItems(), AST::TypeParams(), type, trait))
+        g_compiler_module.add_impl(AST::Impl(AST::MetaItems(), AST::GenericParams(), type, trait))
     impl(g_copy_marker_path, TypeRef(CORETYPE_U8));
     impl(g_copy_marker_path, TypeRef(CORETYPE_U16));
     impl(g_copy_marker_path, TypeRef(CORETYPE_U32));
@@ -49,7 +49,7 @@ void AST_InitProvidedModule_Impls()
     impl(g_sized_marker_path, TypeRef());
     
     {
-        AST::TypeParams tps;
+        AST::GenericParams tps;
         tps.add_ty_param( AST::TypeParam("T") );
         g_compiler_module.add_neg_impl(AST::ImplDef(
             AST::MetaItems(), ::std::move(tps),
diff --git a/src/convert/ast_iterate.cpp b/src/convert/ast_iterate.cpp
index 50936c93..fd4ea614 100644
--- a/src/convert/ast_iterate.cpp
+++ b/src/convert/ast_iterate.cpp
@@ -46,7 +46,7 @@ void CASTIterator::handle_type(TypeRef& type)
 void CASTIterator::handle_expr(AST::ExprNode& node)
 {
 }
-void CASTIterator::handle_params(AST::TypeParams& params)
+void CASTIterator::handle_params(AST::GenericParams& params)
 {
     DEBUG("params");
     for( auto& param : params.ty_params() )
@@ -239,7 +239,7 @@ void CASTIterator::handle_pattern(AST::Pattern& pat, const TypeRef& type_hint)
 }
 void CASTIterator::handle_pattern_enum(
         ::std::vector<TypeRef>& pat_args, const ::std::vector<TypeRef>& hint_args,
-        const AST::TypeParams& enum_params, const AST::EnumVariant& var,
+        const AST::GenericParams& enum_params, const AST::EnumVariant& var,
         ::std::vector<AST::Pattern>& sub_patterns
         )
 {
diff --git a/src/convert/ast_iterate.hpp b/src/convert/ast_iterate.hpp
index 6040290e..3872db58 100644
--- a/src/convert/ast_iterate.hpp
+++ b/src/convert/ast_iterate.hpp
@@ -9,7 +9,7 @@ namespace AST {
 
 class ExprNode;
 class Pattern;
-class TypeParams;
+class GenericParams;
 class Impl;
 class ImplDef;
 class EnumVariant;
@@ -30,7 +30,7 @@ public:
     virtual void handle_type(TypeRef& type);
     virtual void handle_expr(AST::ExprNode& node);
 
-    virtual void handle_params(AST::TypeParams& params);
+    virtual void handle_params(AST::GenericParams& params);
     
     virtual void start_scope();
     virtual void local_type(::std::string name, TypeRef type);
@@ -41,7 +41,7 @@ public:
     virtual void handle_pattern(AST::Pattern& pat, const TypeRef& type_hint);
     virtual void handle_pattern_enum(
             ::std::vector<TypeRef>& pat_args, const ::std::vector<TypeRef>& hint_args,
-            const AST::TypeParams& enum_params, const AST::EnumVariant& var,
+            const AST::GenericParams& enum_params, const AST::EnumVariant& var,
             ::std::vector<AST::Pattern>& sub_patterns
             );
     
diff --git a/src/convert/resolve.cpp b/src/convert/resolve.cpp
index b04147d6..629f7f12 100644
--- a/src/convert/resolve.cpp
+++ b/src/convert/resolve.cpp
@@ -81,7 +81,7 @@ public:
 

     CPathResolver(const AST::Crate& crate);

 

-    void handle_params(AST::TypeParams& params) override;

+    void handle_params(AST::GenericParams& params) override;

 

     virtual void handle_path(AST::Path& path, CASTIterator::PathMode mode) override;

     void handle_path_abs(const Span& span, AST::Path& path, CASTIterator::PathMode mode);

@@ -517,7 +517,7 @@ bool lookup_path_in_module(const Span &span, const AST::Crate& crate, const AST:
 }

 

 /// Perform path resolution within a generic definition block

-void CPathResolver::handle_params(AST::TypeParams& params)

+void CPathResolver::handle_params(AST::GenericParams& params)

 {

     TRACE_FUNCTION;

     // Parameters

diff --git a/src/convert/typecheck_bounds.cpp b/src/convert/typecheck_bounds.cpp
index ed3ae1e2..6af5e778 100644
--- a/src/convert/typecheck_bounds.cpp
+++ b/src/convert/typecheck_bounds.cpp
@@ -11,7 +11,7 @@ class CGenericBoundChecker:
     void check_is_trait(const AST::Path& trait) const;
 public:
     virtual void handle_expr(AST::ExprNode& root) override;
-    virtual void handle_params(AST::TypeParams& params) override;
+    virtual void handle_params(AST::GenericParams& params) override;
 };
 
 void CGenericBoundChecker::handle_expr(AST::ExprNode& root)
@@ -32,7 +32,7 @@ void CGenericBoundChecker::check_is_trait(const AST::Path& trait) const {
     }
 }
 
-void CGenericBoundChecker::handle_params(AST::TypeParams& params)
+void CGenericBoundChecker::handle_params(AST::GenericParams& params)
 {
     for(auto& bound : params.bounds())
     {
diff --git a/src/convert/typecheck_expr.cpp b/src/convert/typecheck_expr.cpp
index ac25982c..69651d7f 100644
--- a/src/convert/typecheck_expr.cpp
+++ b/src/convert/typecheck_expr.cpp
@@ -36,11 +36,11 @@ public:
     virtual void local_type(::std::string name, TypeRef type) override;
     virtual void end_scope() override;
     
-    virtual void handle_params(AST::TypeParams& params) override;
+    virtual void handle_params(AST::GenericParams& params) override;
     
     virtual void handle_pattern_enum(
             ::std::vector<TypeRef>& pat_args, const ::std::vector<TypeRef>& hint_args,
-            const AST::TypeParams& enum_params, const AST::EnumVariant& var,
+            const AST::GenericParams& enum_params, const AST::EnumVariant& var,
             ::std::vector<AST::Pattern>& sub_patterns
             ) override;
     
@@ -57,7 +57,7 @@ private:
     
     void check_enum_variant(
         ::std::vector<TypeRef>& path_args, const ::std::vector<TypeRef>& argtypes,
-        const AST::TypeParams& params, const AST::EnumVariant& var
+        const AST::GenericParams& params, const AST::EnumVariant& var
         );
     void iterate_traits(::std::function<bool(const TypeRef& trait)> fcn);
 };
@@ -103,7 +103,7 @@ void CTypeChecker::end_scope()
     m_scopes.pop_back();
 }
 
-void CTypeChecker::handle_params(AST::TypeParams& params)
+void CTypeChecker::handle_params(AST::GenericParams& params)
 {
     ::std::map<std::string,TypeRef>  trs;
     
@@ -129,7 +129,7 @@ void CTypeChecker::handle_params(AST::TypeParams& params)
 }
 void CTypeChecker::handle_pattern_enum(
         ::std::vector<TypeRef>& pat_args, const ::std::vector<TypeRef>& hint_args,
-        const AST::TypeParams& enum_params, const AST::EnumVariant& var,
+        const AST::GenericParams& enum_params, const AST::EnumVariant& var,
         ::std::vector<AST::Pattern>& sub_patterns
         )
 {
@@ -254,7 +254,7 @@ void CTypeChecker::iterate_traits(::std::function<bool(const TypeRef& trait)> fc
     }
 }
 
-void CTypeChecker::check_enum_variant(::std::vector<TypeRef>& path_args, const ::std::vector<TypeRef>& argtypes, const AST::TypeParams& params, const AST::EnumVariant& var)
+void CTypeChecker::check_enum_variant(::std::vector<TypeRef>& path_args, const ::std::vector<TypeRef>& argtypes, const AST::GenericParams& params, const AST::EnumVariant& var)
 {
     // We know the enum, but it might have type params, need to handle that case
     // TODO: Check for more parameters than required
diff --git a/src/convert/typecheck_params.cpp b/src/convert/typecheck_params.cpp
index eba02653..ea6f74c7 100644
--- a/src/convert/typecheck_params.cpp
+++ b/src/convert/typecheck_params.cpp
@@ -13,13 +13,13 @@ class CGenericParamChecker:
      int    m_within_expr = 0;
     struct LocalType {
         const ::std::string name;
-        const AST::TypeParams*  source_params;  // if nullptr, use fixed_type
+        const AST::GenericParams*  source_params;  // if nullptr, use fixed_type
         TypeRef fixed_type;
     
         LocalType():
             name("")
         {}
-        LocalType(const ::std::string& n, const AST::TypeParams* tps):
+        LocalType(const ::std::string& n, const AST::GenericParams* tps):
             name(n), source_params(tps)
         {}
         LocalType(const ::std::string& n, TypeRef ty):
@@ -43,12 +43,12 @@ public:
     void start_scope() override;
     void local_type(::std::string name, TypeRef type) override;
     void end_scope() override;
-    virtual void handle_params(AST::TypeParams& params) override;
+    virtual void handle_params(AST::GenericParams& params) override;
     
 private:
     bool has_impl_for_param(const ::std::string name, const AST::Path& trait) const;
     bool has_impl(const TypeRef& type, const AST::Path& trait) const;
-    void check_generic_params(const AST::TypeParams& info, ::std::vector<TypeRef>& types, TypeRef self_type, bool allow_infer = false);
+    void check_generic_params(const AST::GenericParams& info, ::std::vector<TypeRef>& types, TypeRef self_type, bool allow_infer = false);
     
     const LocalType* find_type_by_name(const ::std::string& name) const;
 };
@@ -71,7 +71,7 @@ bool CGenericParamChecker::has_impl_for_param(const ::std::string name, const AS
     if( m_crate.is_trait_implicit(trait) )
         return true;
     
-    const AST::TypeParams*  tps = nullptr;
+    const AST::GenericParams*  tps = nullptr;
     // Locate params set that contains the passed name
     for( const auto lt : m_types_stack )
     {
@@ -143,7 +143,7 @@ bool CGenericParamChecker::has_impl(const TypeRef& type, const AST::Path& trait)
 /// \param info Generic item information (param names and bounds)
 /// \param types Type parameters being passed to the generic item
 /// \param allow_infer  Allow inferrence (mutates \a types with conditions from \a info)
-void CGenericParamChecker::check_generic_params(const AST::TypeParams& info, ::std::vector<TypeRef>& types, TypeRef self_type, bool allow_infer)
+void CGenericParamChecker::check_generic_params(const AST::GenericParams& info, ::std::vector<TypeRef>& types, TypeRef self_type, bool allow_infer)
 {
     TRACE_FUNCTION_F("info = " << info << ", types = {" << types << "}");
     // TODO: Need to correctly handle lifetime params here, they should be in a different list
@@ -237,7 +237,7 @@ void CGenericParamChecker::handle_path(AST::Path& path, CASTIterator::PathMode p
     TRACE_FUNCTION_F("path = " << path);
     AST::PathNode& last_node = path[path.size()-1];
     
-    auto comm = [&](const AST::TypeParams& params) {
+    auto comm = [&](const AST::GenericParams& params) {
             auto lt = find_type_by_name("Self");
             TypeRef self_type;  // =TypeRef(TypeRef::TagPath(), path)
             if( lt )
@@ -315,7 +315,7 @@ void CGenericParamChecker::end_scope()
     // pop the separator
     m_types_stack.pop_back();
 }
-void CGenericParamChecker::handle_params(AST::TypeParams& params)
+void CGenericParamChecker::handle_params(AST::GenericParams& params)
 {
     DEBUG("params = " << params);
     for( const auto& p : params.ty_params())
diff --git a/src/dump_as_rust.cpp b/src/dump_as_rust.cpp
index f0355a6f..41043515 100644
--- a/src/dump_as_rust.cpp
+++ b/src/dump_as_rust.cpp
@@ -503,8 +503,8 @@ private:
         m_os << ")";
     }
     
-    void print_params(const AST::TypeParams& params);
-    void print_bounds(const AST::TypeParams& params);
+    void print_params(const AST::GenericParams& params);
+    void print_bounds(const AST::GenericParams& params);
     void print_pattern(const AST::Pattern& p, bool is_refutable);
     void print_type(const TypeRef& t);
     
@@ -642,7 +642,7 @@ void RustPrinter::handle_module(const AST::Module& mod)
     }
 }
 
-void RustPrinter::print_params(const AST::TypeParams& params)
+void RustPrinter::print_params(const AST::GenericParams& params)
 {
     if( params.ty_params().size() > 0 || params.lft_params().size() > 0 )
     {
@@ -670,7 +670,7 @@ void RustPrinter::print_params(const AST::TypeParams& params)
     }
 }
 
-void RustPrinter::print_bounds(const AST::TypeParams& params)
+void RustPrinter::print_bounds(const AST::GenericParams& params)
 {
     if( params.bounds().size() )
     {
diff --git a/src/parse/root.cpp b/src/parse/root.cpp
index d2fc80b1..f7d82987 100644
--- a/src/parse/root.cpp
+++ b/src/parse/root.cpp
@@ -39,7 +39,7 @@ void Parse_ModRoot(TokenStream& lex, AST::Crate& crate, AST::Module& mod, LList<
     return lifetimes;

 }

 /// Parse type parameters in a definition

-void Parse_TypeBound(TokenStream& lex, AST::TypeParams& ret, TypeRef checked_type, ::std::vector< ::std::string> lifetimes = {})

+void Parse_TypeBound(TokenStream& lex, AST::GenericParams& ret, TypeRef checked_type, ::std::vector< ::std::string> lifetimes = {})

 {

     TRACE_FUNCTION;

     Token tok;

@@ -80,11 +80,11 @@ void Parse_TypeBound(TokenStream& lex, AST::TypeParams& ret, TypeRef checked_typ
 }

 

 /// Parse type parameters within '<' and '>' (definition)

-AST::TypeParams Parse_TypeParams(TokenStream& lex)

+AST::GenericParams Parse_GenericParams(TokenStream& lex)

 {

     TRACE_FUNCTION;

 

-    AST::TypeParams ret;

+    AST::GenericParams ret;

     Token tok;

     do {

         bool is_lifetime = false;

@@ -136,7 +136,7 @@ AST::TypeParams Parse_TypeParams(TokenStream& lex)
 

 

 /// Parse the contents of a 'where' clause

-void Parse_WhereClause(TokenStream& lex, AST::TypeParams& params)

+void Parse_WhereClause(TokenStream& lex, AST::GenericParams& params)

 {

     TRACE_FUNCTION;

     Token   tok;

@@ -210,10 +210,10 @@ AST::Function Parse_FunctionDef(TokenStream& lex, ::std::string abi, AST::MetaIt
     Token   tok;

 

     // Parameters

-    AST::TypeParams params;

+    AST::GenericParams params;

     if( GET_TOK(tok, lex) == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

     }

     else {

@@ -359,10 +359,10 @@ AST::TypeAlias Parse_TypeAlias(TokenStream& lex, AST::MetaItems meta_items)
 

     // Params

     tok = lex.getToken();

-    AST::TypeParams params;

+    AST::GenericParams params;

     if( tok.type() == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

         tok = lex.getToken();

     }

@@ -383,10 +383,10 @@ AST::Struct Parse_Struct(TokenStream& lex, const AST::MetaItems meta_items)
     Token   tok;

 

     tok = lex.getToken();

-    AST::TypeParams params;

+    AST::GenericParams params;

     if( tok.type() == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

         tok = lex.getToken();

         if(tok.type() == TOK_RWORD_WHERE)

@@ -484,10 +484,10 @@ AST::Trait Parse_TraitDef(TokenStream& lex, const AST::MetaItems& meta_items)
 

     Token   tok;

     

-    AST::TypeParams params;

+    AST::GenericParams params;

     if( GET_TOK(tok, lex) == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

         tok = lex.getToken();

     }

@@ -614,10 +614,10 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems meta_items)
     

     tok = lex.getToken();

     // Type params supporting "where"

-    AST::TypeParams params;

+    AST::GenericParams params;

     if( tok.type() == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

         tok = lex.getToken();

         if(tok.type() == TOK_RWORD_WHERE)

@@ -713,11 +713,11 @@ void Parse_Impl(TokenStream& lex, AST::Module& mod, bool is_unsafe/*=false*/)
     TRACE_FUNCTION;

     Token   tok;

 

-    AST::TypeParams params;

+    AST::GenericParams params;

     // 1. (optional) type parameters

     if( GET_TOK(tok, lex) == TOK_LT )

     {

-        params = Parse_TypeParams(lex);

+        params = Parse_GenericParams(lex);

         GET_CHECK_TOK(tok, lex, TOK_GT);

     }

     else {

diff --git a/src/synexts/derive.cpp b/src/synexts/derive.cpp
index 92566d06..749da870 100644
--- a/src/synexts/derive.cpp
+++ b/src/synexts/derive.cpp
@@ -24,7 +24,7 @@ static inline AST::ExprNodeP mk_exprnodep(AST::ExprNode* en){ return AST::ExprNo
 /// Interface for derive handlers
 struct Deriver
 {
-    virtual AST::Impl handle_item(const AST::TypeParams& params, const TypeRef& type, const AST::Struct& str) const = 0;
+    virtual AST::Impl handle_item(const AST::GenericParams& params, const TypeRef& type, const AST::Struct& str) const = 0;
 };
 
 /// 'Debug' derive handler
@@ -45,7 +45,7 @@ class Deriver_Debug:
     //}
     
 public:
-    AST::Impl handle_item(const AST::TypeParams& p, const TypeRef& type, const AST::Struct& str) const override
+    AST::Impl handle_item(const AST::GenericParams& p, const TypeRef& type, const AST::Struct& str) const override
     {
         // TODO: be correct herhe and use "core" as the crate name
         // - Requires handling the crate_name crate attribute correctly
@@ -83,7 +83,7 @@ public:
         DEBUG("node = " << *node);
         
         AST::Function fcn(
-            AST::MetaItems(), AST::TypeParams(),
+            AST::MetaItems(), AST::GenericParams(),
             ret_type,
             vec$(
                 ::std::make_pair( AST::Pattern(AST::Pattern::TagBind(), "self"), TypeRef(TypeRef::TagReference(), false, TypeRef("Self")) ),
diff --git a/src/types.cpp b/src/types.cpp
index 2eaf7cd2..7e2a835e 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -327,7 +327,7 @@ bool TypeRef::impls_wildcard(const AST::Crate& crate, const AST::Path& trait) co
         ),
     // Generics are an error?
     (Generic,
-        // TODO: Include an annotation to the TypeParams structure relevant to this type
+        // TODO: Include an annotation to the GenericParams structure relevant to this type
         // - Allows searching the params for the impl, without having to pass the params down
         throw CompileError::Todo("TypeRef::impls_wildcard - param");
         ),
diff --git a/src/types.hpp b/src/types.hpp
index ef3e4d1d..7484d522 100644
--- a/src/types.hpp
+++ b/src/types.hpp
@@ -31,7 +31,7 @@ struct TypeArgRef
 {

     ::std::string   name;

     unsigned int    level;

-    const AST::TypeParams*  params;

+    const AST::GenericParams*  params;

 };

 

 struct Type_Function:

@@ -84,7 +84,7 @@ TAGGED_UNION(TypeData, None,
     (Generic, (

         ::std::string name;

         unsigned int level;

-        const AST::TypeParams* params;

+        const ::AST::GenericParams* params;

         )),

     (Path, (

         AST::Path path;

@@ -185,7 +185,7 @@ public:
     TypeRef(TagArg, ::std::string name):

         m_data(TypeData::make_Generic({ name, 0, nullptr }))

     {}

-    TypeRef(TagArg, ::std::string name, const AST::TypeParams& params):

+    TypeRef(TagArg, ::std::string name, const AST::GenericParams& params):

         m_data(TypeData::make_Generic({ name, 0, &params }))

     {}

     TypeRef(::std::string name):

@@ -231,9 +231,9 @@ public:
     

     bool is_type_param() const { return m_data.is_Generic(); }

     const ::std::string& type_param() const { return m_data.as_Generic().name; }

-    void set_type_params_ptr(const AST::TypeParams& p) { m_data.as_Generic().params = &p; };

-    const AST::TypeParams* type_params_ptr() const {

-        return reinterpret_cast<const AST::TypeParams*>( m_data.as_Generic().params );

+    void set_type_params_ptr(const AST::GenericParams& p) { m_data.as_Generic().params = &p; };

+    const AST::GenericParams* type_params_ptr() const {

+        return reinterpret_cast<const AST::GenericParams*>( m_data.as_Generic().params );

     }

     

     bool is_reference() const { return m_data.is_Borrow(); }