Changeset 64eae56 for src/GenPoly

Timestamp:

Dec 21, 2016, 5:15:27 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:

0c286cf

Parents:

53e3b4a

Message:

match formal parameter type of actual function when specializing ttype parameter, flatten types when unifying ttype parameters

File:

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

src/GenPoly/Specialize.cc ¶

@@ -194 +194 @@
         }
 
+        /// restructures arg to match the structure of a single formal parameter. Assumes that atomic types are compatible (as the Resolver should have ensured this)
+        template< typename OutIterator >
+        void matchOneFormal( Expression * arg, unsigned & idx, Type * formal, OutIterator out ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formal ) ) {
+                        std::list< Expression * > exprs;
+                        for ( Type * t : *tupleType ) {
+                                matchOneFormal( arg, idx, t, back_inserter( exprs ) );
+                        }
+                        *out++ = new TupleExpr( exprs );
+                } else {
+                        *out++ = new TupleIndexExpr( arg->clone(), idx++ );
+                }
+        }
+
+        /// restructures the ttype argument to match the structure of the formal parameters of the actual function.
+        // [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 ) {
@@ -203 +220 @@
                 unsigned idx = 0;
                 for ( ; begin != end; ++begin ) {
-                        // DeclarationWithType * formal = *begin;
-                        // Type * formalType = formal->get_type();
-                        args.push_back( new TupleIndexExpr( last->clone(), idx++ ) );
+                        DeclarationWithType * formal = *begin;
+                        Type * formalType = formal->get_type();
+                        matchOneFormal( last, idx, formalType, back_inserter( args ) );
                 }
                 delete last;
@@ -238 +255 @@
 
                 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;
-                        assert( begin != end );
 
                         // std::cerr << "thunk param: " << param << std::endl;