Changeset 6c3a988f for src/GenPoly

Timestamp:

Jan 5, 2017, 3:47:36 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:

f831177

Parents:

1e3d5b6

Message:

fix inferred parameter data structures to correctly associate parameters with the entity that requested them, modify tuple specialization and unification to work with self-recursive assertions

Location:

src/GenPoly

Files:

• Box.cc (modified) (1 diff)
• Specialize.cc (modified) (9 diffs)

src/GenPoly/Box.cc

@@ -783 +783 @@
                 void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
-                                assert( arg != appExpr->get_args().end() );
+                                assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
                                 addCast( *arg, (*param)->get_type(), exprTyVars );
                                 boxParam( (*param)->get_type(), *arg, exprTyVars );

src/GenPoly/Specialize.cc

@@ -112 +112 @@
                 FunctionType *newType = funType->clone();
                 if ( env ) {
-                        TypeSubstitution newEnv( *env );
                         // it is important to replace only occurrences of type variables that occur free in the
                         // thunk's type
-                        newEnv.applyFree( newType );
+                        env->applyFree( newType );
                 } // if
                 // create new thunk with same signature as formal type (C linkage, empty body)
@@ -167 +166 @@
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
-                        FunctionType *funType;
-                        if ( ( funType = getFunctionType( formalType ) ) ) {
+                        if ( FunctionType *funType = getFunctionType( formalType ) ) {
                                 ApplicationExpr *appExpr;
                                 VariableExpr *varExpr;
@@ -188 +186 @@
 
         bool TupleSpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
-                // std::cerr << "asking if type needs tuple spec: " << formalType << std::endl;
                 if ( FunctionType * ftype = getFunctionType( formalType ) ) {
                         return ftype->isTtype();
@@ -215 +212 @@
         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...
+                safe_dynamic_cast< TupleType * >( last->get_result() );
                 unsigned idx = 0;
                 for ( ; begin != end; ++begin ) {
@@ -227 +224 @@
         Expression * TupleSpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
                 static UniqueName thunkNamer( "_tupleThunk" );
-                // std::cerr << "creating tuple thunk for " << funType << std::endl;
 
                 FunctionType *newType = funType->clone();
                 if ( env ) {
-                        TypeSubstitution newEnv( *env );
                         // it is important to replace only occurrences of type variables that occur free in the
                         // thunk's type
-                        newEnv.applyFree( newType );
+                        env->applyFree( newType );
                 } // if
                 // create new thunk with same signature as formal type (C linkage, empty body)
@@ -246 +241 @@
                 UniqueName paramNamer( paramPrefix );
                 ApplicationExpr *appExpr = new ApplicationExpr( actual );
-                // std::cerr << actual << std::endl;
-
-                FunctionType * actualType = getFunctionType( actual->get_result() );
+
+                FunctionType * actualType = getFunctionType( actual->get_result() )->clone();
+                if ( env ) {
+                        // need to apply the environment to the actual function's type, since it may itself be polymorphic
+                        env->apply( actualType );
+                }
+                std::unique_ptr< FunctionType > actualTypeManager( actualType ); // for RAII
                 std::list< DeclarationWithType * >::iterator actualBegin = actualType->get_parameters().begin();
                 std::list< DeclarationWithType * >::iterator actualEnd = actualType->get_parameters().end();
@@ -282 +281 @@
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                spec.handleExplicitParams( appExpr );
+                spec.mutate( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
@@ -297 +296 @@
                 } // if
                 thunkFunc->get_statements()->get_kids().push_back( appStmt );
-
-                // std::cerr << "thunkFunc is: " << thunkFunc << std::endl;
 
                 // add thunk definition to queue of statements to add
@@ -326 +323 @@
                         // don't need to do this for intrinsic calls, because they aren't actually passed
                         for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
-                                inferParam->second.expr = specializer->doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
+                                inferParam->second.expr = specializer->doSpecialization( inferParam->second.formalType, inferParam->second.expr, inferParam->second.inferParams.get() );
                         }
                         handleExplicitParams( appExpr );