Changeset 2f42718 for src/CodeTools

Timestamp:

Feb 22, 2019, 10:43:29 AM (7 years ago)

Author:

tdelisle <tdelisle@…>

Branches:

no_list

Parents:

43e0949

Message:

Parameters and return value of functions are now vectors (and some related clean-up)

Location:

src/CodeTools

Files:

• DeclStats.cc (modified) (6 diffs)
• ResolvProtoDump.cc (modified) (6 diffs)

src/CodeTools/DeclStats.cc

@@ -183 +183 @@
                 }
 
-                void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats,
+                void analyzeSubtypes( std::vector<DeclarationWithType*>& tys, Stats& stats,
                                 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
-                                unsigned& max_depth, unsigned depth, unsigned& n_subs ) {
+                                unsigned& max_depth, unsigned depth, unsigned& n_subs )
+                {
                         for ( DeclarationWithType* dwt : tys ) {
                                 Type* ty = dwt->get_type();
@@ -204 +205 @@
                 }
 
-                void analyzeSubtypes( std::list<Type*>& tys, Stats& stats,
+                void analyzeSubtypes( std::vector<Type*>& tys, Stats& stats,
                                 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
                                 unsigned& max_depth, unsigned depth ) {
@@ -246 +247 @@
                                 unsigned n_subs = 0;
                                 analyzeSubtypes(
-                                        ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
+                                        ft->returnVals, stats, elSeen, n_poly, seen_poly, max_depth, depth,
                                         n_subs );
                                 analyzeSubtypes(
-                                        ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
+                                        ft->parameters, stats, elSeen, n_poly, seen_poly, max_depth, depth,
                                         n_subs );
                                 ++stats.n_generic_params.at( n_subs );
@@ -280 +281 @@
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
                                 analyzeSubtypes(
-                                        tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
+                                        tt->types, stats, elSeen, n_poly, seen_poly, max_depth, depth );
                                 ++stats.n_generic_params.at( tt->size() );
                         } else if ( dynamic_cast<VarArgsType*>(ty) ) {
@@ -299 +300 @@
 
                 /// Update arg pack stats based on a declaration list
-                void analyze( Stats& stats, std::unordered_set<std::string>& seen,
-                                std::unordered_set<std::string>& elSeen, ArgPackStats& pstats,
-                                std::list<DeclarationWithType*>& decls ) {
+                void analyze( Stats& stats, std::unordered_set<std::string> & seen,
+                                std::unordered_set<std::string> & elSeen, ArgPackStats & pstats,
+                                std::vector<DeclarationWithType*> & decls ) {
                         std::unordered_set<std::string> types;
                         unsigned n = 0;                 ///< number of args/returns
@@ -345 +346 @@
                         std::unordered_set<std::string> seen;
                         std::unordered_set<std::string> elSeen;
-                        analyze( stats, seen, elSeen, params, fnTy->get_parameters() );
-                        analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() );
+                        analyze( stats, seen, elSeen, params , fnTy->parameters );
+                        analyze( stats, seen, elSeen, returns, fnTy->returnVals );
                 }
 

src/CodeTools/ResolvProtoDump.cc

@@ -102 +102 @@
                 /// builds space-separated list of types
                 template<typename V>
-                static void build( V& visitor, const std::list< Type* >& tys, std::stringstream& ss,
+                static void build( V& visitor, const std::vector< Type* >& tys, std::stringstream& ss,
                                 septype mode = separated ) {
                         if ( tys.empty() ) return;
@@ -121 +121 @@
                 /// builds list of types wrapped as tuple type
                 template<typename V>
-                static void buildAsTuple( V& visitor, const std::list< Type* >& tys,
+                static void buildAsTuple( V& visitor, const std::vector< Type * > & tys,
                                 std::stringstream& ss ) {
                         switch ( tys.size() ) {
@@ -135 +135 @@
 
                 /// gets types from DWT list
-                static std::list< Type* > from_decls( const std::list< DeclarationWithType* >& decls ) {
-                        std::list< Type* > tys;
+                static std::vector< Type * > from_decls( const std::vector< DeclarationWithType * > & decls ) {
+                        std::vector< Type * > tys;
                         for ( auto decl : decls ) { tys.emplace_back( decl->get_type() ); }
                         return tys;
@@ -142 +142 @@
 
                 /// gets types from TypeExpr list
-                static std::list< Type* > from_exprs( const std::list< Expression* >& exprs ) {
-                        std::list< Type* > tys;
+                static std::vector< Type* > from_exprs( const std::list< Expression* >& exprs ) {
+                        std::vector< Type* > tys;
                         for ( auto expr : exprs ) {
                                 if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(expr) ) {
@@ -587 +587 @@
 
                 /// Adds all named declarations in a list to the local scope
-                void addAll( const std::list<DeclarationWithType*>& decls ) {
+                void addAll( const std::vector<DeclarationWithType*>& decls ) {
                         for ( auto decl : decls ) {
                                 // skip anonymous decls
@@ -644 +644 @@
                         // add body if available
                         if ( decl->statements ) {
-                                std::list<Type*> rtns = from_decls( decl->type->returnVals );
+                                auto rtns = from_decls( decl->type->returnVals );
                                 Type* rtn = nullptr;
                                 if ( rtns.size() == 1 ) {