From 5481c481d9120732f447fc108a1cf86659fda579 Mon Sep 17 00:00:00 2001 From: John Hodge Date: Sat, 30 Jan 2016 15:58:42 +0800 Subject: Rename TypeParams to GenericParams --- src/ast/ast.cpp | 14 ++++----- src/ast/ast.hpp | 68 ++++++++++++++++++++-------------------- src/ast/path.cpp | 2 +- src/ast/path.hpp | 4 +-- src/ast/provided_module.cpp | 6 ++-- src/convert/ast_iterate.cpp | 4 +-- src/convert/ast_iterate.hpp | 6 ++-- src/convert/resolve.cpp | 4 +-- src/convert/typecheck_bounds.cpp | 4 +-- src/convert/typecheck_expr.cpp | 12 +++---- src/convert/typecheck_params.cpp | 16 +++++----- src/dump_as_rust.cpp | 8 ++--- src/parse/root.cpp | 32 +++++++++---------- src/synexts/derive.cpp | 6 ++-- src/types.cpp | 2 +- src/types.hpp | 12 +++---- 16 files changed, 100 insertions(+), 100 deletions(-) (limited to 'src') 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& 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& 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& types) const +bool GenericParams::check_params(Crate& crate, const ::std::vector& types) const { return check_params( crate, const_cast< ::std::vector&>(types), false ); } -bool TypeParams::check_params(Crate& crate, ::std::vector& types, bool allow_infer) const +bool GenericParams::check_params(Crate& crate, ::std::vector& 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& 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 m_type_params; ::std::vector< ::std::string > m_lifetime_params; ::std::vector 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& types) const; bool check_params(Crate& crate, ::std::vector& 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 m_supertraits; ItemList m_types; ItemList m_functions; public: Trait() {} - Trait(MetaItems attrs, TypeParams params, ::std::vector supertraits): + Trait(MetaItems attrs, GenericParams params, ::std::vector 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& supertraits() const { return m_supertraits; } const ItemList& functions() const { return m_functions; } const ItemList& types() const { return m_types; } - TypeParams& params() { return m_params; } + GenericParams& params() { return m_params; } ::std::vector& supertraits() { return m_supertraits; } ItemList& functions() { return m_functions; } ItemList& types() { return m_types; } void add_type(::std::string name, TypeRef type) { - m_types.push_back( Item(move(name), TypeAlias(MetaItems(), TypeParams(), move(type)), true) ); + m_types.push_back( Item(move(name), TypeAlias(MetaItems(), GenericParams(), move(type)), true) ); } void add_function(::std::string name, Function fcn) { m_functions.push_back( Item(::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 m_variants; public: Enum() {} - Enum( MetaItems attrs, TypeParams params, ::std::vector variants ): + Enum( MetaItems attrs, GenericParams params, ::std::vector 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& variants() const { return m_variants; } - TypeParams& params() { return m_params; } + GenericParams& params() { return m_params; } ::std::vector& 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 m_fields; public: Struct() {} - Struct( MetaItems attrs, TypeParams params, ::std::vector fields ): + Struct( MetaItems attrs, GenericParams params, ::std::vector 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& fields() const { return m_fields; } MetaItems& attrs() { return m_attrs; } - TypeParams& params() { return m_params; } + GenericParams& params() { return m_params; } ::std::vector& fields() { return m_fields; } TypeRef get_field_type(const char *name, const ::std::vector& 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& m_args; public: - GenericResolveClosure(const AST::TypeParams& params, const ::std::vector& args): + GenericResolveClosure(const AST::GenericParams& params, const ::std::vector& 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& nodes_a, const ::std::vector& nodes_b, ::std::function fcn); static int node_lists_equal_no_generic(const ::std::vector& nodes_a, const ::std::vector& 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& 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::Struct( AST::MetaItems(), AST::GenericParams(), ::std::vector { 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& pat_args, const ::std::vector& hint_args, - const AST::TypeParams& enum_params, const AST::EnumVariant& var, + const AST::GenericParams& enum_params, const AST::EnumVariant& var, ::std::vector& 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& pat_args, const ::std::vector& hint_args, - const AST::TypeParams& enum_params, const AST::EnumVariant& var, + const AST::GenericParams& enum_params, const AST::EnumVariant& var, ::std::vector& 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& pat_args, const ::std::vector& hint_args, - const AST::TypeParams& enum_params, const AST::EnumVariant& var, + const AST::GenericParams& enum_params, const AST::EnumVariant& var, ::std::vector& sub_patterns ) override; @@ -57,7 +57,7 @@ private: void check_enum_variant( ::std::vector& path_args, const ::std::vector& argtypes, - const AST::TypeParams& params, const AST::EnumVariant& var + const AST::GenericParams& params, const AST::EnumVariant& var ); void iterate_traits(::std::function 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 trs; @@ -129,7 +129,7 @@ void CTypeChecker::handle_params(AST::TypeParams& params) } void CTypeChecker::handle_pattern_enum( ::std::vector& pat_args, const ::std::vector& hint_args, - const AST::TypeParams& enum_params, const AST::EnumVariant& var, + const AST::GenericParams& enum_params, const AST::EnumVariant& var, ::std::vector& sub_patterns ) { @@ -254,7 +254,7 @@ void CTypeChecker::iterate_traits(::std::function fc } } -void CTypeChecker::check_enum_variant(::std::vector& path_args, const ::std::vector& argtypes, const AST::TypeParams& params, const AST::EnumVariant& var) +void CTypeChecker::check_enum_variant(::std::vector& path_args, const ::std::vector& 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& types, TypeRef self_type, bool allow_infer = false); + void check_generic_params(const AST::GenericParams& info, ::std::vector& 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& types, TypeRef self_type, bool allow_infer) +void CGenericParamChecker::check_generic_params(const AST::GenericParams& info, ::std::vector& 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, ¶ms })) {} 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( 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( m_data.as_Generic().params ); } bool is_reference() const { return m_data.is_Borrow(); } -- cgit v1.2.3