Changeset d9fa60a for src/GenPoly/Box.cc

Timestamp:

Nov 16, 2016, 4:37:50 PM (7 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:

186fd86

Parents:

33a7b6d

Message:

moved substituion into MemberExpr? constructor, change generated tuple structs to generic structs, tuples containing type variables almost works

File:

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

src/GenPoly/Box.cc

@@ -98 +98 @@
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
@@ -107 +107 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -769 +769 @@
                 }
 
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
@@ -818 +818 @@
 
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
-                        // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
-                        // if ( useRetval ) {
-                        //      assert( retval );
-                        //      arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
-                        //      arg++;
-                        // } else {
-
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.  Possibly change comma expression into statement expression "{}" for multiple
                         // return values.
+                        assert( retType );
                         ObjectDecl *newObj = makeTemporary( retType->clone() );
                         Expression *paramExpr = new VariableExpr( newObj );
@@ -843 +837 @@
                         appExpr->set_env( 0 );
                         return commaExpr;
-                        // } // if
-                        // return appExpr;
                 }
 
@@ -878 +870 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
@@ -1288 +1280 @@
                         TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
-                        ReferenceToType *concRetType = dynamic_cast< ReferenceToType* >( appExpr->get_result() ); // xxx - is concRetType a good name?
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
+                        Type *concRetType = appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
 
                         if ( dynRetType ) {
@@ -1589 +1581 @@
                         // move polymorphic return type to parameter list
                         if ( isDynRet( funcType ) ) {
-                                DeclarationWithType *ret = funcType->get_returnVals().front();
+                                ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
                                 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
                                 funcType->get_parameters().push_front( ret );
                                 funcType->get_returnVals().pop_front();
+                                ret->set_init( nullptr ); // xxx - memory leak?
                         }