Changeset 4c8621ac for src/GenPoly

Timestamp:

Dec 22, 2016, 4:07:58 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1e3d5b6

Parents:

907eccb

Message:

allow construction, destruction, and assignment for empty tuples, allow matching a ttype parameter with an empty tuple, fix specialization to work with empty tuples and void functions

File:

• src/GenPoly/Specialize.cc (modified) (3 diffs)

src/GenPoly/Specialize.cc

@@ -32 +32 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
+#include "Tuples/Tuples.h"
 
 namespace GenPoly {
@@ -211 +212 @@
         // [begin, end) are the formal parameters.
         // args is the list of arguments currently given to the actual function, the last of which needs to be restructured.
-        template< typename Iterator >
-        void fixLastArg( std::list< Expression * > & args, Iterator begin, Iterator end ) {
-                assertf( ! args.empty(), "Somehow args to tuple function are empty" ); // xxx - it's quite possible this will trigger for the nullary case...
-                Expression * last = args.back();
+        template< typename Iterator, typename OutIterator >
+        void fixLastArg( Expression * last, Iterator begin, Iterator end, OutIterator out ) {
                 // safe_dynamic_cast for the assertion
                 safe_dynamic_cast< TupleType * >( last->get_result() ); // xxx - it's quite possible this will trigger for the unary case...
-                args.pop_back(); // replace last argument in the call with
                 unsigned idx = 0;
                 for ( ; begin != end; ++begin ) {
                         DeclarationWithType * formal = *begin;
                         Type * formalType = formal->get_type();
-                        matchOneFormal( last, idx, formalType, back_inserter( args ) );
+                        matchOneFormal( last, idx, formalType, out );
                 }
                 delete last;
@@ -251 +249 @@
 
                 FunctionType * actualType = getFunctionType( actual->get_result() );
-                std::list< DeclarationWithType * >::iterator begin = actualType->get_parameters().begin();
-                std::list< DeclarationWithType * >::iterator end = actualType->get_parameters().end();
-
+                std::list< DeclarationWithType * >::iterator actualBegin = actualType->get_parameters().begin();
+                std::list< DeclarationWithType * >::iterator actualEnd = actualType->get_parameters().end();
+                std::list< DeclarationWithType * >::iterator formalBegin = funType->get_parameters().begin();
+                std::list< DeclarationWithType * >::iterator formalEnd = funType->get_parameters().end();
+
+                Expression * last = nullptr;
                 for ( DeclarationWithType* param : thunkFunc->get_functionType()->get_parameters() ) {
                         // walk the parameters to the actual function alongside the parameters to the thunk to find the location where the ttype parameter begins to satisfy parameters in the actual function.
-                        assert( begin != end );
-                        ++begin;
-
-                        // std::cerr << "thunk param: " << param << std::endl;
-                        // last param will always be a tuple type... expand it into the actual type(?)
                         param->set_name( paramNamer.newName() );
+                        assertf( formalBegin != formalEnd, "Reached end of formal parameters before finding ttype parameter" );
+                        if ( Tuples::isTtype((*formalBegin)->get_type()) ) {
+                                last = new VariableExpr( param );
+                                break;
+                        }
+                        assertf( actualBegin != actualEnd, "reached end of actual function's arguments before finding ttype parameter" );
+                        ++actualBegin;
+                        ++formalBegin;
+
                         appExpr->get_args().push_back( new VariableExpr( param ) );
                 } // for
-                fixLastArg( appExpr->get_args(), --begin, end );
+                assert( last );
+                fixLastArg( last, actualBegin, actualEnd, back_inserter( appExpr->get_args() ) );
                 appExpr->set_env( maybeClone( env ) );
                 if ( inferParams ) {