Changes in src/GenPoly/Box.cc [5802a4f:dd0c97b]

File:

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

src/GenPoly/Box.cc

@@ -136 +136 @@
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
-
-                        using PolyMutator::mutate;
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
                         virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
@@ -686 +691 @@
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assert(paramType && "Aggregate parameters should be type expressions");
+                                assertf(paramType, "Aggregate parameters should be type expressions");
                                 paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
                         }
@@ -783 +788 @@
                 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 );
@@ -1127 +1132 @@
                         makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?)
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
-                        Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
-
+
+                        // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
+                        // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
+                        // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         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
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
@@ -1142 +1150 @@
                         arg = appExpr->get_args().begin();
 
+                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
                         passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
                         addInferredParams( appExpr, function, arg, exprTyVars );
@@ -1271 +1280 @@
                 template< typename DeclClass >
                 DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
                         return ret;
@@ -1305 +1314 @@
                 }
 
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
+                        // prevent tyVars from leaking into containing scope
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
                 TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
@@ -1310 +1336 @@
                                 return handleDecl( typeDecl, typeDecl->get_base() );
                         } else {
-                                return Mutator::mutate( typeDecl );
+                                return Parent::mutate( typeDecl );
                         }
                 }
@@ -1322 +1348 @@
                         makeTyVarMap( pointerType, scopeTyVars );
 
-                        Type *ret = Mutator::mutate( pointerType );
+                        Type *ret = Parent::mutate( pointerType );
 
                         scopeTyVars.endScope();