Changeset 64eae56 for src

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

Location:

src

Files:

• GenPoly/Specialize.cc (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (1 diff)
• tests/tupleVariadic.c (modified) (1 diff)

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;

src/ResolvExpr/Unify.cc

@@ -491 +491 @@
                 std::list< Type * > types;
                 for ( ; begin != end; ++begin ) {
-                        // might need to break apart these types too?
-                        // yes, looks like we should flatten begin and push back each types individually
-                        types.push_back( (*begin)->get_type()->clone() );
+                        // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple
+                        flatten( (*begin)->get_type(), back_inserter( types ) );
                 }
                 return new TupleType( Type::Qualifiers(), types );

src/tests/tupleVariadic.c

@@ -57 +57 @@
 }
 
-void ?{}(array * a, int a0, int a1, int a2, int a3) {
+// test use of a tuple argument
+[void] ?{}(array * a, [int, int, int, int] args) {
+        int a0, a1, a2, a3;
+        [a0, a1, a2, a3] = args;
         a->size = 4;
-        a->data = (int*)malloc(sizeof(int)*a->size);
+        a->data = malloc(sizeof(int)*a->size);
         a->data[0] = a0;
         a->data[1] = a1;