Changeset 2f42718 for src/ResolvExpr

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/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (5 diffs)
• ConversionCost.cc (modified) (1 diff)
• FindOpenVars.cc (modified) (1 diff)
• SpecCost.cc (modified) (3 diffs)
• Unify.cc (modified) (7 diffs)
• typeops.h (modified) (3 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -434 +434 @@
 
                 Cost convCost = Cost::zero;
-                std::list< DeclarationWithType* >& formals = function->parameters;
-                std::list< DeclarationWithType* >::iterator formal = formals.begin();
-                std::list< Expression* >& actuals = appExpr->args;
+                auto & formals = function->parameters;
+                auto   formal  = formals.begin();
+                auto & actuals = appExpr->args;
 
                 for ( Expression*& actualExpr : actuals ) {
@@ -493 +493 @@
         /// Adds type variables to the open variable set and marks their assertions
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
-                        for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->assertions.begin(); assert != (*tyvar)->assertions.end(); ++assert ) {
-                                needAssertions[ *assert ].isUsed = true;
+                for ( auto tyvar : type->forall ) {
+                        unifiableVars[ tyvar->get_name() ] = TypeDecl::Data{ tyvar };
+                        for ( auto assert : tyvar->assertions ) {
+                                needAssertions[ assert ].isUsed = true;
                         }
                 }
@@ -1407 +1407 @@
                         // assume no polymorphism
                         // assume no implicit conversions
-                        assert( function->get_parameters().size() == 1 );
+                        assert( function->parameters.size() == 1 );
                         PRINT(
                                 std::cerr << "resolvAttr: funcDecl is ";
@@ -1417 +1417 @@
                         const SymTab::Indexer & indexer = finder.get_indexer();
                         AltList & alternatives = finder.get_alternatives();
-                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                        if ( typesCompatibleIgnoreQualifiers( argType, function->parameters.front()->get_type(), indexer, env ) ) {
                                 Cost cost = Cost::zero;
                                 Expression * newExpr = data.combine( cost );
@@ -1442 +1442 @@
                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( id->get_type() ) ) {
                                         // assume exactly one parameter
-                                        if ( function->get_parameters().size() == 1 ) {
+                                        if ( function->parameters.size() == 1 ) {
                                                 if ( attrExpr->get_isType() ) {
                                                         resolveAttr( data, function, attrExpr->get_type(), env, altFinder);

src/ResolvExpr/ConversionCost.cc

@@ -388 +388 @@
                 Cost c = Cost::zero;
                 if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
-                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
-                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
+                        std::vector< Type * >::const_iterator srcIt = tupleType->types.begin();
+                        std::vector< Type * >::const_iterator destIt = destAsTuple->types.begin();
                         while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
                                 Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env );

src/ResolvExpr/FindOpenVars.cc

@@ -50 +50 @@
         void FindOpenVars::common_action( Type *type ) {
                 if ( nextIsOpen ) {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
-                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        needAssertions[ *assert ].isUsed = false;
+                        for ( const auto i : type->get_forall() ) {
+                                openVars[ i->get_name() ] = TypeDecl::Data{ i };
+                                for ( const auto assert : i->assertions ) {
+                                        needAssertions[ assert ].isUsed = false;
                                 }
-///       cloneAll( (*i)->get_assertions(), needAssertions );
-///       needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
                         }
                 } else {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
-                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        haveAssertions[ *assert ].isUsed = false;
+                        for ( const auto i : type->get_forall() ) {
+                                closedVars[ i->get_name() ] = TypeDecl::Data{ i };
+                                for ( const auto assert : i->assertions ) {
+                                        haveAssertions[ assert ].isUsed = false;
                                 }
-///       cloneAll( (*i)->get_assertions(), haveAssertions );
-///       haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
                         } // for
                 } // if
-///   std::cerr << "type is ";
-///   type->print( std::cerr );
-///   std::cerr << std::endl << "need is" << std::endl;
-///   printAssertionSet( needAssertions, std::cerr );
-///   std::cerr << std::endl << "have is" << std::endl;
-///   printAssertionSet( haveAssertions, std::cerr );
         }
 

src/ResolvExpr/SpecCost.cc

@@ -42 +42 @@
         private:
                 // takes minimum non-negative count over parameter/return list
-                void takeminover( int& mincount, std::list<DeclarationWithType*>& dwts ) {
+                void takeminover( int& mincount, std::vector<DeclarationWithType*> & dwts ) {
                         for ( DeclarationWithType* dwt : dwts ) {
                                 count = -1;
@@ -61 +61 @@
                         visit_children = false;
                 }
-        
+
         private:
                 // returns minimum non-negative count + 1 over type parameters (-1 if none such)
@@ -80 +80 @@
                         visit_children = false;
                 }
-                
+
                 // look for polymorphic parameters
                 void previsit(UnionInstType* uty) {

src/ResolvExpr/Unify.cc

@@ -283 +283 @@
         void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) {
                 for ( auto tyvar : type->get_forall() ) {
-                        for ( auto assert : tyvar->get_assertions() ) {
+                        for ( auto assert : tyvar->assertions ) {
                                 markAssertionSet( assertion1, assert );
                                 markAssertionSet( assertion2, assert );
@@ -336 +336 @@
         template< typename Iterator, typename Func >
         std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end, Func & toType ) {
-                std::list< Type * > types;
+                std::vector< Type * > types;
                 for ( ; begin != end; ++begin ) {
                         // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple
@@ -404 +404 @@
         /// flattens a list of declarations, so that each tuple type has a single declaration.
         /// makes use of TtypeExpander to ensure ttypes are flat as well.
-        void flattenList( std::list< DeclarationWithType * > src, std::list< DeclarationWithType * > & dst, TypeEnvironment & env ) {
+        void flattenList( std::vector< DeclarationWithType * > src, std::vector< DeclarationWithType * > & dst, TypeEnvironment & env ) {
                 dst.clear();
                 for ( DeclarationWithType * dcl : src ) {
@@ -429 +429 @@
                         std::unique_ptr<FunctionType> flatFunc( functionType->clone() );
                         std::unique_ptr<FunctionType> flatOther( otherFunction->clone() );
-                        flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env );
-                        flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env );
+                        flattenList( flatFunc ->parameters, flatFunc ->parameters, env );
+                        flattenList( flatOther->parameters, flatOther->parameters, env );
 
                         // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors
@@ -481 +481 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                std::list< Type * > binderTypes;
+                                std::vector< Type * > binderTypes;
 
                                 do {
@@ -497 +497 @@
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                std::list< Type * > binderTypes;
+                                std::vector< Type * > binderTypes;
 
                                 do {
@@ -626 +626 @@
         // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
-                if ( function->get_returnVals().size() == 0 ) {
+                if ( function->returnVals.size() == 0 ) {
                         return new VoidType( Type::Qualifiers() );
-                } else if ( function->get_returnVals().size() == 1 ) {
-                        return function->get_returnVals().front()->get_type()->clone();
+                } else if ( function->returnVals.size() == 1 ) {
+                        return function->returnVals.front()->get_type()->clone();
                 } else {
-                        std::list< Type * > types;
-                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
+                        std::vector< Type * > types;
+                        for ( DeclarationWithType * decl : function->returnVals ) {
                                 types.push_back( decl->get_type()->clone() );
                         } // for

src/ResolvExpr/typeops.h

@@ -73 +73 @@
 
         // in AlternativeFinder.cc
-        Cost computeConversionCost( Type *actualType, Type *formalType, 
+        Cost computeConversionCost( Type *actualType, Type *formalType,
                 const SymTab::Indexer &indexer, const TypeEnvironment &env );
 
@@ -112 +112 @@
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
 
-        template<typename Iter> 
+        template<typename Iter>
         bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) {
                 while ( begin != end ) {
@@ -128 +128 @@
         void flatten( Type * type, OutputIterator out ) {
                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : tupleType->get_types() ) {
+                        for ( Type * t : tupleType->types ) {
                                 flatten( t, out );
                         }