Changes in src/GenPoly/Box.cc [8ca3a72:d7dc824]

File:

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

src/GenPoly/Box.cc

@@ -62 +62 @@
 namespace GenPoly {
         namespace {
+                const std::list<Label> noLabels;
+
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
@@ -101 +103 @@
                         void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
+                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
                         /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
                         void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
@@ -108 +110 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -134 +136 @@
                   public:
                         template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        DeclClass *handleDecl( DeclClass *decl );
                         template< typename AggDecl >
                         AggDecl * handleAggDecl( AggDecl * aggDecl );
@@ -663 +665 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -726 +728 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, function, concrete, arg );
+                        return addRetParam( appExpr, concrete, arg );
                 }
 
@@ -737 +739 @@
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
+                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
                         } // if
                         std::string mangleName = mangleAdapterName( function, tyVars );
@@ -1146 +1148 @@
                         if ( dynRetType ) {
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
-                                ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
                                 // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
@@ -1280 +1282 @@
 
                 template< typename DeclClass >
-                DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
@@ -1294 +1296 @@
 
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
+                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1319 +1321 @@
 
                 ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
+                        return handleDecl( objectDecl );
                 }
 
@@ -1342 +1344 @@
                         addToTyVarMap( typeDecl, scopeTyVars );
                         if ( typeDecl->get_base() ) {
-                                return handleDecl( typeDecl, typeDecl->get_base() );
+                                return handleDecl( typeDecl );
                         } else {
                                 return Parent::mutate( typeDecl );
@@ -1349 +1351 @@
 
                 TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                        return handleDecl( typedefDecl );
                 }