Changes in src/GenPoly/Box.cc [271a5d3:474a170]

File:

• src/GenPoly/Box.cc (modified) (16 diffs)

src/GenPoly/Box.cc

@@ -37 +37 @@
 #include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
 #include "Lvalue.h"                      // for generalizedLvalue
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 #include "ScopedSet.h"                   // for ScopedSet, ScopedSet<>::iter...
@@ -95 +94 @@
                   private:
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
-                        void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
+                        /// Will insert 0, 2 or 3 more arguments.
+                        std::list< Expression *>::iterator passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
                         /// Returns an iterator to the first argument after the added
@@ -488 +488 @@
                                 makeTyVarMap( functionType, scopeTyVars );
 
-                                std::list< DeclarationWithType *> &paramList = functionType->parameters;
                                 std::list< FunctionType const *> functions;
                                 for ( TypeDecl * const tyVar : functionType->forall ) {
@@ -495 +494 @@
                                         } // for
                                 } // for
-                                for ( DeclarationWithType * const arg : paramList ) {
+                                for ( DeclarationWithType * const arg : functionType->parameters ) {
                                         findFunction( arg->get_type(), functions, scopeTyVars, needsAdapter );
                                 } // for
@@ -532 +531 @@
                 }
 
-                void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
+                std::list< Expression *>::iterator Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
                         Type *polyType = isPolyType( parmType, exprTyVars );
                         if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
                                 std::string typeName = mangleType( polyType );
-                                if ( seenTypes.count( typeName ) ) return;
+                                if ( seenTypes.count( typeName ) ) return arg;
 
                                 arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
@@ -556 +555 @@
                                 seenTypes.insert( typeName );
                         }
+                        return arg;
                 }
 
@@ -562 +562 @@
                         std::list< Expression *>::iterator arg = appExpr->args.begin();
                         // pass size/align for type variables
+                        // NOTE: This is iterating over a map. This means the sorting
+                        // order of the keys changes behaviour, as the iteration order
+                        // is visible outside the loop. - The order matches the orignal
+                        // order because the vars have been renamed with numbers that,
+                        // even when converted to strings, sort in the original order.
+                        // (At least, that is the best explination I have.)
                         for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
-                                ResolvExpr::EqvClass eqvClass;
-                                if ( tyParam.second.isComplete ) {
-                                        Type *concrete = env->lookup( tyParam.first );
-                                        // If there is an unbound type variable, it should have detected already.
-                                        assertf( concrete, "Unbound type variable: %s in: %s",
-                                                toCString( tyParam.first ), toCString( *env ) );
-
-                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
-                                        arg++;
-                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
-                                        arg++;
-                                } // if
+                                if ( !tyParam.second.isComplete ) continue;
+                                Type *concrete = env->lookup( tyParam.first );
+                                // If there is an unbound type variable, it should have detected already.
+                                assertf( concrete, "Unbound type variable: %s in: %s",
+                                        toCString( tyParam.first ), toCString( *env ) );
+
+                                arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
+                                arg++;
+                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
+                                arg++;
                         } // for
 
@@ -582 +586 @@
                         assert( funcType );
 
-                        // These iterators don't advance in unison.
-                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
-                        std::list< Expression* >::const_iterator fnArg = arg;
-                        std::set< std::string > seenTypes; ///< names for generic types we've seen
+                        // Iterator over the original function arguments.
+                        std::list< Expression* >::const_iterator fnArg;
+                        // Names for generic types we've seen.
+                        std::set< std::string > seenTypes;
 
                         // a polymorphic return type may need to be added to the argument list
                         if ( polyRetType ) {
                                 Type *concRetType = replaceWithConcrete( polyRetType, env );
-                                passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
-                                ++fnArg; // skip the return parameter in the argument list
+                                arg = passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
+                                // Skip the return parameter in the argument list.
+                                fnArg = arg + 1;
+                        } else {
+                                fnArg = arg;
                         }
 
                         // add type information args for presently unseen types in parameter list
+                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
-                                if ( ! (*fnArg)->get_result() ) continue;
                                 Type * argType = (*fnArg)->get_result();
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
+                                if ( ! argType ) continue;
+                                arg = passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
                         }
                         return arg;
@@ -680 +688 @@
                 Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
                         Expression *ret = appExpr;
-//                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, scopeTyVars ) ) {
                                 ret = addRetParam( appExpr, function->returnVals.front()->get_type() );
@@ -772 +779 @@
 
                 void Pass1::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
-                        std::list< Expression *>::iterator cur = arg;
                         for ( TypeDecl * const tyVar : functionType->forall ) {
                                 for ( DeclarationWithType * const assert : tyVar->assertions ) {
@@ -779 +785 @@
                                         Expression *newExpr = inferParam->second.expr->clone();
                                         boxParam( newExpr, assert->get_type(), tyVars );
-                                        appExpr->get_args().insert( cur, newExpr );
+                                        arg = appExpr->get_args().insert( arg, newExpr );
+                                        ++arg;
                                 } // for
                         } // for
@@ -922 +929 @@
                                 // only attempt to create an adapter or pass one as a parameter if we haven't already done so for this
                                 // pre-substitution parameter function type.
-                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
+                                // The second part of the insert result is "is the value new".
+                                if ( adaptersDone.insert( mangleName ).second ) {
 
                                         // apply substitution to type variables to figure out what the adapter's type should look like
@@ -1106 +1113 @@
 
                         Expression *ret = appExpr;
+                        // Save iterator to the first original parameter (works with lists).
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
@@ -1172 +1180 @@
 
                 void Pass1::premutate( AddressExpr * ) { visit_children = false; }
+
                 Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->arg->result && ! addrExpr->arg->result->isVoid() );
@@ -1232 +1241 @@
 
                 void Pass2::addAdapters( FunctionType *functionType ) {
-                        std::list< DeclarationWithType *> &paramList = functionType->parameters;
                         std::list< FunctionType const *> functions;
                         for ( DeclarationWithType * const arg : functionType->parameters ) {
@@ -1245 +1253 @@
                                         std::string adapterName = makeAdapterName( mangleName );
                                         // adapter may not be used in body, pass along with unused attribute.
-                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
+                                        functionType->parameters.push_front(
+                                                new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 }
                         }
-//  deleteAll( functions );
                 }