Index: translator/GenPoly/Box.cc
===================================================================
--- translator/GenPoly/Box.cc	(revision 17cd4ebabb684710b2f3698449093c4e84b8fb70)
+++ translator/GenPoly/Box.cc	(revision f7f6785834eaf341228a98a2b3786030fe9329ba)
@@ -33,444 +33,389 @@
 
 namespace GenPoly {
-
-namespace {
-
-const std::list<Label> noLabels;
-
-class Pass1 : public PolyMutator
-{
-public:
-  Pass1();
-  virtual Expression *mutate( ApplicationExpr *appExpr );
-  virtual Expression *mutate( AddressExpr *addrExpr );
-  virtual Expression *mutate( UntypedExpr *expr );
-  virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
-  virtual TypeDecl* mutate( TypeDecl *typeDecl );
-  virtual Expression *mutate( CommaExpr *commaExpr );
-  virtual Expression *mutate( ConditionalExpr *condExpr );
-  virtual Statement* mutate(ReturnStmt *catchStmt);
-  virtual Type* mutate( PointerType *pointerType );
-  virtual Type* mutate( FunctionType *pointerType );
-  
-  virtual void doEndScope();
-  
-private:
-  void passTypeVars( ApplicationExpr* appExpr, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars );
-  Expression* addRetParam( ApplicationExpr* appExpr, FunctionType *function, Type *retType, std::list< Expression* >::iterator &arg );
-  Expression* addPolyRetParam( ApplicationExpr* appExpr, FunctionType *function, std::string typeName, 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 );
-  void boxParams( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars );
-  void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars );
-  void findAssignOps( const std::list< TypeDecl* > &forall );
-  void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
-  FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
-  Expression *handleIntrinsics( ApplicationExpr *appExpr );
-  ObjectDecl *makeTemporary( Type *type );
-  
-  std::map< std::string, DeclarationWithType* > assignOps;
-  std::map< std::string, FunctionDecl* > adapters;
-  DeclarationWithType* retval;
-  bool useRetval;
-  UniqueName tempNamer;
-};
-
-class Pass2 : public PolyMutator
-{
-public:
-  Pass2();
-  template< typename DeclClass >
-  DeclClass* handleDecl( DeclClass *decl, Type *type );
-  virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
-  virtual ObjectDecl* mutate( ObjectDecl *objectDecl );
-  virtual TypeDecl* mutate( TypeDecl *typeDecl );
-  virtual TypedefDecl* mutate( TypedefDecl *typedefDecl );
-  virtual Type* mutate( PointerType *pointerType );
-  virtual Type* mutate( FunctionType *funcType );
-
-private:
-  void addAdapters( FunctionType *functionType );
-  
-  std::map< UniqueId, std::string > adapterName;
-};
-
-class Pass3 : public PolyMutator
-{
-public:
-  template< typename DeclClass >
-  DeclClass* handleDecl( DeclClass *decl, Type *type );
-  virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
-  virtual ObjectDecl* mutate( ObjectDecl *objectDecl );
-  virtual TypedefDecl* mutate( TypedefDecl *objectDecl );
-  virtual TypeDecl* mutate( TypeDecl *objectDecl );
-  virtual Statement* mutate( DeclStmt *declStmt );
-  virtual Type* mutate( PointerType *pointerType );
-  virtual Type* mutate( FunctionType *funcType );
-
-private:
-};
-
-} // anonymous namespace
-
-void
-printAllNotBuiltin( const std::list< Declaration* >& translationUnit, std::ostream &os )
-{
-  for( std::list< Declaration* >::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
-    if( !LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
-      (*i)->print( os );
-      os << std::endl;
+    namespace {
+	const std::list<Label> noLabels;
+
+	class Pass1 : public PolyMutator {
+	  public:
+	    Pass1();
+	    virtual Expression *mutate( ApplicationExpr *appExpr );
+	    virtual Expression *mutate( AddressExpr *addrExpr );
+	    virtual Expression *mutate( UntypedExpr *expr );
+	    virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
+	    virtual TypeDecl *mutate( TypeDecl *typeDecl );
+	    virtual Expression *mutate( CommaExpr *commaExpr );
+	    virtual Expression *mutate( ConditionalExpr *condExpr );
+	    virtual Statement *mutate(ReturnStmt *catchStmt);
+	    virtual Type *mutate( PointerType *pointerType );
+	    virtual Type *mutate( FunctionType *pointerType );
+  
+	    virtual void doEndScope();
+	  private:
+	    void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+	    Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
+	    Expression *addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, 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 );
+	    void boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+	    void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
+	    void findAssignOps( const std::list< TypeDecl *> &forall );
+	    void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
+	    FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
+	    Expression *handleIntrinsics( ApplicationExpr *appExpr );
+	    ObjectDecl *makeTemporary( Type *type );
+  
+	    std::map< std::string, DeclarationWithType *> assignOps;
+	    std::map< std::string, FunctionDecl *> adapters;
+	    DeclarationWithType *retval;
+	    bool useRetval;
+	    UniqueName tempNamer;
+	};
+
+	class Pass2 : public PolyMutator {
+	  public:
+	    Pass2();
+	    template< typename DeclClass >
+	    DeclClass *handleDecl( DeclClass *decl, Type *type );
+	    virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
+	    virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
+	    virtual TypeDecl *mutate( TypeDecl *typeDecl );
+	    virtual TypedefDecl *mutate( TypedefDecl *typedefDecl );
+	    virtual Type *mutate( PointerType *pointerType );
+	    virtual Type *mutate( FunctionType *funcType );
+	  private:
+	    void addAdapters( FunctionType *functionType );
+  
+	    std::map< UniqueId, std::string > adapterName;
+	};
+
+	class Pass3 : public PolyMutator {
+	  public:
+	    template< typename DeclClass >
+	    DeclClass *handleDecl( DeclClass *decl, Type *type );
+	    virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
+	    virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
+	    virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
+	    virtual TypeDecl *mutate( TypeDecl *objectDecl );
+	    virtual Statement *mutate( DeclStmt *declStmt );
+	    virtual Type *mutate( PointerType *pointerType );
+	    virtual Type *mutate( FunctionType *funcType );
+	  private:
+	};
+
+    } // anonymous namespace
+
+    void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) {
+	for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
+	    if ( !LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
+		(*i)->print( os );
+		os << std::endl;
+	    } // if
+	} // for
     }
-  }
-}
-
-void
-box( std::list< Declaration* >& translationUnit )
-{
-  Pass1 pass1;
-  Pass2 pass2;
-  Pass3 pass3;
-  mutateAll( translationUnit, pass1 );
-  mutateAll( translationUnit, pass2 );
-  mutateAll( translationUnit, pass3 );
-}
+
+    void box( std::list< Declaration *>& translationUnit ) {
+	Pass1 pass1;
+	Pass2 pass2;
+	Pass3 pass3;
+	mutateAll( translationUnit, pass1 );
+	mutateAll( translationUnit, pass2 );
+	mutateAll( translationUnit, pass3 );
+    }
 
 ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 
-namespace {
-
-bool
-isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars )
-{
-  bool doTransform = false;
-  if( !function->get_returnVals().empty() ) {
-    if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( function->get_returnVals().front()->get_type() ) ) {
+    namespace {
+	bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars ) {
+	    bool doTransform = false;
+	    if ( !function->get_returnVals().empty() ) {
+		if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( function->get_returnVals().front()->get_type() ) ) {
     
-      // figure out if the return type is specified by a type parameter
-      for( std::list< TypeDecl* >::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
-        if( (*tyVar)->get_name() == typeInst->get_name() ) {
-          doTransform = true;
-          name = typeInst->get_name();
-          break;
-        }
-      }
-      if( !doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
-        doTransform = true;
-      }
-    }
-  }
-  return doTransform;
-}
-
-bool
-isPolyRet( FunctionType *function, std::string &name )
-{
-  TyVarMap dummyTyVars;
-  return isPolyRet( function, name, dummyTyVars );
-}
-
-Pass1::Pass1()
-  : useRetval( false ), tempNamer( "_temp" )
-{
-}
-
-bool
-checkAssignment( DeclarationWithType *decl, std::string &name )
-{
-  if( decl->get_name() == "?=?" ) {
-    if( PointerType *ptrType = dynamic_cast< PointerType* >( decl->get_type() ) ) {
-      if( FunctionType *funType = dynamic_cast< FunctionType* >( ptrType->get_base() ) ) {
-        if( funType->get_parameters().size() == 2 ) {
-          if( PointerType *pointer = dynamic_cast< PointerType* >( funType->get_parameters().front()->get_type() ) ) {
-            if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
-              name = typeInst->get_name();
-              return true;
-            }
-          }
-        }
-      }
-    }
-  }
-  return false;
-}
-
-void 
-Pass1::findAssignOps( const std::list< TypeDecl* > &forall )
-{
-  assignOps.clear();
-  for( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
-    for( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-      std::string typeName;
-      if( checkAssignment( *assert, typeName ) ) {
-        assignOps[ typeName ] = *assert;
-      }
-    }
-  }
-}
-
-DeclarationWithType* 
-Pass1::mutate( FunctionDecl *functionDecl )
-{
-  if( functionDecl->get_statements() ) {
-    TyVarMap oldtyVars = scopeTyVars;
-    DeclarationWithType *oldRetval = retval;
-    bool oldUseRetval = useRetval;
+		    // figure out if the return type is specified by a type parameter
+		    for ( std::list< TypeDecl *>::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
+			if ( (*tyVar)->get_name() == typeInst->get_name() ) {
+			    doTransform = true;
+			    name = typeInst->get_name();
+			    break;
+			} // if
+		    } // for
+		    if ( !doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
+			doTransform = true;
+		    } // if
+		} // if
+	    } // if
+	    return doTransform;
+	}
+
+	bool isPolyRet( FunctionType *function, std::string &name ) {
+	    TyVarMap dummyTyVars;
+	    return isPolyRet( function, name, dummyTyVars );
+	}
+
+	Pass1::Pass1()
+	    : useRetval( false ), tempNamer( "_temp" ) {
+	}
+
+	bool checkAssignment( DeclarationWithType *decl, std::string &name ) {
+	    if ( decl->get_name() == "?=?" ) {
+		if ( PointerType *ptrType = dynamic_cast< PointerType *>( decl->get_type() ) ) {
+		    if ( FunctionType *funType = dynamic_cast< FunctionType *>( ptrType->get_base() ) ) {
+			if ( funType->get_parameters().size() == 2 ) {
+			    if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
+				if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
+				    name = typeInst->get_name();
+				    return true;
+				} // if
+			    } // if
+			} // if
+		    } // if
+		} // if
+	    } // if
+	    return false;
+	}
+
+	void Pass1::findAssignOps( const std::list< TypeDecl *> &forall ) {
+	    assignOps.clear();
+	    for ( std::list< TypeDecl *>::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+		for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
+		    std::string typeName;
+		    if ( checkAssignment( *assert, typeName ) ) {
+			assignOps[ typeName ] = *assert;
+		    } // if
+		} // for
+	    } // for
+	}
+
+	DeclarationWithType *
+	Pass1::mutate( FunctionDecl *functionDecl ) {
+	    if ( functionDecl->get_statements() ) {
+		TyVarMap oldtyVars = scopeTyVars;
+		DeclarationWithType *oldRetval = retval;
+		bool oldUseRetval = useRetval;
     
-    retval = 0;
-    std::string typeName;
-    if( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
-      retval = functionDecl->get_functionType()->get_returnVals().front();
-  
-      // give names to unnamed return values
-      if( retval->get_name() == "" ) {
-        retval->set_name( "_retparm" );
-        retval->set_linkage( LinkageSpec::C );
-      }
-    }
+		retval = 0;
+		std::string typeName;
+		if ( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
+		    retval = functionDecl->get_functionType()->get_returnVals().front();
+  
+		    // give names to unnamed return values
+		    if ( retval->get_name() == "" ) {
+			retval->set_name( "_retparm" );
+			retval->set_linkage( LinkageSpec::C );
+		    } // if
+		} // if
     
-    scopeTyVars.clear();
+		scopeTyVars.clear();
 ///     std::cerr << "clear\n";
-    makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
-    findAssignOps( functionDecl->get_functionType()->get_forall() );
-    functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-  
-    scopeTyVars = oldtyVars;
+		makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+		findAssignOps( functionDecl->get_functionType()->get_forall() );
+		functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
+  
+		scopeTyVars = oldtyVars;
 ///     std::cerr << "end FunctionDecl: ";
-///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
+///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 ///       std::cerr << i->first << " ";
 ///     }
 ///     std::cerr << "\n";
-    retval = oldRetval;
-    useRetval = oldUseRetval;
-    doEndScope();
-  }
-  return functionDecl;
-}
-
-TypeDecl*
-Pass1::mutate( TypeDecl *typeDecl )
-{
+		retval = oldRetval;
+		useRetval = oldUseRetval;
+		doEndScope();
+	    } // if
+	    return functionDecl;
+	}
+
+	TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
 ///     std::cerr << "add " << typeDecl->get_name() << "\n";
-  scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-  return Mutator::mutate( typeDecl );
-}
-
-Expression *
-Pass1::mutate( CommaExpr *commaExpr )
-{
-  bool oldUseRetval = useRetval;
-  useRetval = false;
-  commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
-  useRetval = oldUseRetval;
-  commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
-  return commaExpr;
-}
-
-Expression *
-Pass1::mutate( ConditionalExpr *condExpr )
-{
-  bool oldUseRetval = useRetval;
-  useRetval = false;
-  condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
-  useRetval = oldUseRetval;
-  condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
-  condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
-  return condExpr;
-
-}
-
-void
-Pass1::passTypeVars( ApplicationExpr* appExpr, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars )
-{
-  for( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
-    ResolvExpr::EqvClass eqvClass;
-    assert( env );
-    if( tyParm->second == TypeDecl::Any ) {
-      Type *concrete = env->lookup( tyParm->first );
-      if( concrete ) {
-        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
-        arg++;
-      } else {
-        throw SemanticError( "unbound type variable in application ", appExpr );
-      }
-    }
-  }
-}
-
-ObjectDecl*
-Pass1::makeTemporary( Type *type )
-{
-  ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 );
-  stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
-  return newObj;
-}
-
-TypeInstType *
-isPolyType( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
-{
-  if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-    if( env ) {
-      if( Type *newType = env->lookup( typeInst->get_name() ) ) {
-        return isPolyType( newType, env, tyVars );
-      }
-    }
-    if( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
-      return typeInst;
-    } else {
-      return 0;
-    }
-  } else {
-    return 0;
-  }
-}
-
-Expression*
-Pass1::addRetParam( ApplicationExpr* appExpr, FunctionType *function, Type *retType, std::list< Expression* >::iterator &arg )
-{
-  if( useRetval ) {
-    assert( retval );
-    arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
-    arg++;
-  } else {
-    ObjectDecl *newObj = makeTemporary( retType->clone() );
-    Expression *paramExpr = new VariableExpr( newObj );
-    if( !isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
-      paramExpr = new AddressExpr( paramExpr );
-    }
-    arg = appExpr->get_args().insert( arg, paramExpr );
-    arg++;
+	    scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
+	    return Mutator::mutate( typeDecl );
+	}
+
+	Expression *Pass1::mutate( CommaExpr *commaExpr ) {
+	    bool oldUseRetval = useRetval;
+	    useRetval = false;
+	    commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
+	    useRetval = oldUseRetval;
+	    commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
+	    return commaExpr;
+	}
+
+	Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
+	    bool oldUseRetval = useRetval;
+	    useRetval = false;
+	    condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
+	    useRetval = oldUseRetval;
+	    condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
+	    condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
+	    return condExpr;
+
+	}
+
+	void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+	    for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
+		ResolvExpr::EqvClass eqvClass;
+		assert( env );
+		if ( tyParm->second == TypeDecl::Any ) {
+		    Type *concrete = env->lookup( tyParm->first );
+		    if ( concrete ) {
+			arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
+			arg++;
+		    } else {
+			throw SemanticError( "unbound type variable in application ", appExpr );
+		    } // if
+		} // if
+	    } // for
+	}
+
+	ObjectDecl *Pass1::makeTemporary( Type *type ) {
+	    ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 );
+	    stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+	    return newObj;
+	}
+
+	TypeInstType *isPolyType( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
+	    if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+		if ( env ) {
+		    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+			return isPolyType( newType, env, tyVars );
+		    } // if
+		} // if
+		if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
+		    return typeInst;
+		} else {
+		    return 0;
+		} // if
+	    } else {
+		return 0;
+	    } // if
+	}
+
+	Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+	    if ( useRetval ) {
+		assert( retval );
+		arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
+		arg++;
+	    } else {
+		ObjectDecl *newObj = makeTemporary( retType->clone() );
+		Expression *paramExpr = new VariableExpr( newObj );
+		if ( !isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
+		    paramExpr = new AddressExpr( paramExpr );
+		} // if
+		arg = appExpr->get_args().insert( arg, paramExpr );
+		arg++;
 ///     stmtsToAdd.push_back( new ExprStmt( noLabels, appExpr ) );
-    CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
-    commaExpr->set_env( appExpr->get_env() );
-    appExpr->set_env( 0 );
-    return commaExpr;
-  }
-  return appExpr;
-}
-
-Expression*
-Pass1::addPolyRetParam( ApplicationExpr* appExpr, FunctionType *function, std::string typeName, std::list< Expression* >::iterator &arg )
-{
-  ResolvExpr::EqvClass eqvClass;
-  assert( env );
-  Type *concrete = env->lookup( typeName );
-  if( concrete == 0 ) {
-    throw SemanticError( "Unbound type variable " + typeName + " in", appExpr );
-  }
-  return addRetParam( appExpr, function, concrete, arg );
-}
-
-Expression*
-Pass1::applyAdapter( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars )
-{
-  Expression *ret = appExpr;
-  if( !function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
-    ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
-  }
-  appExpr->get_args().push_front( appExpr->get_function() );
-  appExpr->set_function( new NameExpr( "_adapter" + SymTab::Mangler::mangle( function ) ) );
-  
-  return ret;
-}
-
-void
-Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars )
-{
-  assert( !arg->get_results().empty() );
-///   if( !dynamic_cast< PointerType* >( arg->get_results().front() ) ) {
-    TypeInstType *typeInst = dynamic_cast< TypeInstType* >( param );
-    if( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
-      if( arg->get_results().front()->get_isLvalue() ) {
-        arg = new AddressExpr( arg );
-      } else {
-        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
-        newObj->get_type()->get_qualifiers() = Type::Qualifiers();
-        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
-        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-        assign->get_args().push_back( new VariableExpr( newObj ) );
-        assign->get_args().push_back( arg );
-        stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
-        arg = new AddressExpr( new VariableExpr( newObj ) );
-      }
-    }
+		CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
+		commaExpr->set_env( appExpr->get_env() );
+		appExpr->set_env( 0 );
+		return commaExpr;
+	    } // if
+	    return appExpr;
+	}
+
+	Expression *Pass1::addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, std::list< Expression *>::iterator &arg ) {
+	    ResolvExpr::EqvClass eqvClass;
+	    assert( env );
+	    Type *concrete = env->lookup( typeName );
+	    if ( concrete == 0 ) {
+		throw SemanticError( "Unbound type variable " + typeName + " in", appExpr );
+	    } // if
+	    return addRetParam( appExpr, function, concrete, arg );
+	}
+
+	Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+	    Expression *ret = appExpr;
+	    if ( !function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
+		ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
+	    } // if
+	    appExpr->get_args().push_front( appExpr->get_function() );
+	    appExpr->set_function( new NameExpr( "_adapter" + SymTab::Mangler::mangle( function ) ) );
+  
+	    return ret;
+	}
+
+	void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
+	    assert( !arg->get_results().empty() );
+///   if ( !dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
+	    TypeInstType *typeInst = dynamic_cast< TypeInstType *>( param );
+	    if ( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
+		if ( arg->get_results().front()->get_isLvalue() ) {
+		    arg = new AddressExpr( arg );
+		} else {
+		    ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
+		    newObj->get_type()->get_qualifiers() = Type::Qualifiers();
+		    stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+		    UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+		    assign->get_args().push_back( new VariableExpr( newObj ) );
+		    assign->get_args().push_back( arg );
+		    stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
+		    arg = new AddressExpr( new VariableExpr( newObj ) );
+		} // if
+	    } // if
 ///   }
-}
-
-void
-addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars )
-{
-  Type *newType = formal->clone();
-  std::list< FunctionType* > functions;
-  // instead of functions needing adapters, this really ought to look for
-  // any function mentioning a polymorphic type
-  findAndReplaceFunction( newType, functions, tyVars, needsAdapter );
-  if( !functions.empty() ) {
-    actual = new CastExpr( actual, newType );
-  } else {
-    delete newType;
-  }
-}
-
-void
-Pass1::boxParams( ApplicationExpr* appExpr, FunctionType *function, std::list< Expression* >::iterator &arg, const TyVarMap &exprTyVars )
-{
+	}
+
+	void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
+	    Type *newType = formal->clone();
+	    std::list< FunctionType *> functions;
+	    // instead of functions needing adapters, this really ought to look for
+	    // any function mentioning a polymorphic type
+	    findAndReplaceFunction( newType, functions, tyVars, needsAdapter );
+	    if ( !functions.empty() ) {
+		actual = new CastExpr( actual, newType );
+	    } else {
+		delete newType;
+	    } // if
+	}
+
+	void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
 ///   std::cout << "function is ";
 ///   function->print( std::cout );
-  for( std::list< DeclarationWithType* >::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
+	    for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
 ///     std::cout << "parameter is ";
 ///     (*param)->print( std::cout );
 ///     std::cout << std::endl << "argument is ";
 ///     (*arg)->print( std::cout );
-    assert( arg != appExpr->get_args().end() );
-    addCast( *arg, (*param)->get_type(), exprTyVars );
-    boxParam( (*param)->get_type(), *arg, exprTyVars );
-  }
-}
-
-void
-Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression* >::iterator &arg, const TyVarMap &tyVars )
-{
-  std::list< Expression* >::iterator cur = arg;
-  for( std::list< TypeDecl* >::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-    for( std::list< DeclarationWithType* >::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
-      InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
-      assert( inferParam != appExpr->get_inferParams().end() );
-      Expression *newExpr = inferParam->second.expr->clone();
-      addCast( newExpr, (*assert)->get_type(), tyVars );
-      boxParam( (*assert)->get_type(), newExpr, tyVars );
-      appExpr->get_args().insert( cur, newExpr );
-    }
-  }
-}
-
-void
-makeRetParm( FunctionType *funcType )
-{
-  DeclarationWithType *retParm = funcType->get_returnVals().front();
-
-  // make a new parameter that is a pointer to the type of the old return value
-  retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
-  funcType->get_parameters().push_front( retParm );
-
-  // we don't need the return value any more
-  funcType->get_returnVals().clear();
-}
-
-FunctionType *
-makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars )
-{
-  // actually make the adapter type
-  FunctionType *adapter = adaptee->clone();
-  if( !adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
-    makeRetParm( adapter );
-  }
-  adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
-  return adapter;
-}
-
-Expression*
-makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars )
-{
-  assert( param );
-  assert( arg );
+		assert( arg != appExpr->get_args().end() );
+		addCast( *arg, (*param)->get_type(), exprTyVars );
+		boxParam( (*param)->get_type(), *arg, exprTyVars );
+	    } // for
+	}
+
+	void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+	    std::list< Expression *>::iterator cur = arg;
+	    for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+		for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+		    InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
+		    assert( inferParam != appExpr->get_inferParams().end() );
+		    Expression *newExpr = inferParam->second.expr->clone();
+		    addCast( newExpr, (*assert)->get_type(), tyVars );
+		    boxParam( (*assert)->get_type(), newExpr, tyVars );
+		    appExpr->get_args().insert( cur, newExpr );
+		} // for
+	    } // for
+	}
+
+	void makeRetParm( FunctionType *funcType ) {
+	    DeclarationWithType *retParm = funcType->get_returnVals().front();
+
+	    // make a new parameter that is a pointer to the type of the old return value
+	    retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
+	    funcType->get_parameters().push_front( retParm );
+
+	    // we don't need the return value any more
+	    funcType->get_returnVals().clear();
+	}
+
+	FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ) {
+	    // actually make the adapter type
+	    FunctionType *adapter = adaptee->clone();
+	    if ( !adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
+		makeRetParm( adapter );
+	    } // if
+	    adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
+	    return adapter;
+	}
+
+	Expression *makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars ) {
+	    assert( param );
+	    assert( arg );
 ///   std::cout << "arg type is ";
 ///   arg->get_type()->print( std::cout );
@@ -479,665 +424,619 @@
 ///   std::cout << " tyVars are: ";
 ///   printTyVarMap( std::cout, tyVars );
-  if( isPolyVal( realParam->get_type(), tyVars ) ) {
-///     if( dynamic_cast< PointerType* >( arg->get_type() ) ) {
+	    if ( isPolyVal( realParam->get_type(), tyVars ) ) {
+///     if ( dynamic_cast< PointerType *>( arg->get_type() ) ) {
 ///       return new CastExpr( new VariableExpr( param ), arg->get_type()->clone() );
 ///     } else {
-      UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-      deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-      deref->get_results().push_back( arg->get_type()->clone() );
-      return deref;
+		UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+		deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+		deref->get_results().push_back( arg->get_type()->clone() );
+		return deref;
 ///     }
-  }
-  return new VariableExpr( param );
-}
-
-void
-addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType* >::iterator arg, std::list< DeclarationWithType* >::iterator param, std::list< DeclarationWithType* >::iterator paramEnd, std::list< DeclarationWithType* >::iterator realParam, const TyVarMap &tyVars )
-{
-  UniqueName paramNamer( "_p" );
-  for( ; param != paramEnd; ++param, ++arg, ++realParam ) {
-    if( (*param)->get_name() == "" ) {
-      (*param)->set_name( paramNamer.newName() );
-      (*param)->set_linkage( LinkageSpec::C );
-    }
-    adapteeApp->get_args().push_back( makeAdapterArg( *param, *arg, *realParam, tyVars ) );
-  }
-}
-
-FunctionDecl *
-Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars )
-{
-  FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
-  adapterType = ScrubTyVars::scrub( adapterType, tyVars );
-  DeclarationWithType *adapteeDecl = adapterType->get_parameters().front();
-  adapteeDecl->set_name( "_adaptee" );
-  ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
-  Statement *bodyStmt;
-  
-  std::list< TypeDecl* >::iterator tyArg = realType->get_forall().begin();
-  std::list< TypeDecl* >::iterator tyParam = adapterType->get_forall().begin();
-  std::list< TypeDecl* >::iterator realTyParam = adaptee->get_forall().begin();
-  for( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
-    assert( tyArg != realType->get_forall().end() );
-    std::list< DeclarationWithType* >::iterator assertArg = (*tyArg)->get_assertions().begin();
-    std::list< DeclarationWithType* >::iterator assertParam = (*tyParam)->get_assertions().begin();
-    std::list< DeclarationWithType* >::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
-    for( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
-      assert( assertArg != (*tyArg)->get_assertions().end() );
-      adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
-    }
-  }
-  
-  std::list< DeclarationWithType* >::iterator arg = realType->get_parameters().begin();
-  std::list< DeclarationWithType* >::iterator param = adapterType->get_parameters().begin();
-  std::list< DeclarationWithType* >::iterator realParam = adaptee->get_parameters().begin();
-  param++;		// skip adaptee parameter
-  if( realType->get_returnVals().empty() ) {
-    addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-    bodyStmt = new ExprStmt( noLabels, adapteeApp );
-  } else if( isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
-    if( (*param)->get_name() == "" ) {
-      (*param)->set_name( "_ret" );
-      (*param)->set_linkage( LinkageSpec::C );
-    }
-    UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-    UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-    deref->get_args().push_back( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
-    assign->get_args().push_back( deref );
-    addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-    assign->get_args().push_back( adapteeApp );
-    bodyStmt = new ExprStmt( noLabels, assign );
-  } else {
-    // adapter for a function that returns a monomorphic value
-    addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-    bodyStmt = new ReturnStmt( noLabels, adapteeApp );
-  }
-  CompoundStmt *adapterBody = new CompoundStmt( noLabels );
-  adapterBody->get_kids().push_back( bodyStmt );
-  return new FunctionDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
-}
-
-void
-Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars )
-{
-  std::list< DeclarationWithType* > &paramList = functionType->get_parameters();
-  std::list< FunctionType* > functions;
-  for( std::list< TypeDecl* >::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-    for( std::list< DeclarationWithType* >::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
-      findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
-    }
-  }
-  for( std::list< DeclarationWithType* >::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-    findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
-  }
-  std::set< std::string > adaptersDone;
-  for( std::list< FunctionType* >::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-    FunctionType *realFunction = (*funType)->clone();
-    assert( env );
-    env->apply( realFunction );
-    std::string mangleName = SymTab::Mangler::mangle( realFunction );
-    if( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-      std::map< std::string, FunctionDecl* >::iterator adapter = adapters.find( mangleName );
-      if( adapter == adapters.end() ) {
-        FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
-        adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl* >( mangleName, newAdapter ) );
-        stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
-      }
-      assert( adapter != adapters.end() );
-      appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
-      adaptersDone.insert( adaptersDone.begin(), mangleName );
-    }
-  }
-}
-
-TypeInstType*
-isPolyPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
-{
-  if( PointerType *ptr = dynamic_cast< PointerType* >( type ) ) {
-    return isPolyType( ptr->get_base(), env, tyVars );
-  } else if( env ) {
-    if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-      if( Type *newType = env->lookup( typeInst->get_name() ) ) {
-        return isPolyPtr( newType, env, tyVars );
-      }
-    }
-  }
-  return 0;
-}
-
-TypeInstType*
-isPolyPtrPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars )
-{
-  if( PointerType *ptr = dynamic_cast< PointerType* >( type ) ) {
-    return isPolyPtr( ptr->get_base(), env, tyVars );
-  } else if( env ) {
-    if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-      if( Type *newType = env->lookup( typeInst->get_name() ) ) {
-        return isPolyPtrPtr( newType, env, tyVars );
-      }
-    }
-  }
-  return 0;
-}
-
-Expression *
-makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr )
-{
-  NameExpr *opExpr;
-  if( isIncr ) {
-    opExpr = new NameExpr( "?+=?" );
-  } else {
-    opExpr = new NameExpr( "?-=?" );
-  }
-  UntypedExpr *addAssign = new UntypedExpr( opExpr );
-  if( AddressExpr *address = dynamic_cast< AddressExpr* >( appExpr->get_args().front() ) ) {
-    addAssign->get_args().push_back( address->get_arg() );
-  } else {
-    addAssign->get_args().push_back( appExpr->get_args().front() );
-  }
-  addAssign->get_args().push_back( new NameExpr( polyName ) );
-  addAssign->get_results().front() = appExpr->get_results().front()->clone();
-  if( appExpr->get_env() ) {
-    addAssign->set_env( appExpr->get_env() );
-    appExpr->set_env( 0 );
-  }
-  appExpr->get_args().clear();
-  delete appExpr;
-  return addAssign;
-}
-
-Expression*
-Pass1::handleIntrinsics( ApplicationExpr *appExpr )
-{
-  if( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
-    if( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
-      if( varExpr->get_var()->get_name() == "?[?]" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( appExpr->get_args().size() == 2 );
-        TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
-        TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
-        assert( !typeInst1 || !typeInst2 );
-        UntypedExpr *ret = 0;
-        if( typeInst1 || typeInst2 ) {
-          ret = new UntypedExpr( new NameExpr( "?+?" ) );
-        }
-        if( typeInst1 ) {
-          UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
-          multiply->get_args().push_back( appExpr->get_args().back() );
-          multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
-          ret->get_args().push_back( appExpr->get_args().front() );
-          ret->get_args().push_back( multiply );
-        } else if( typeInst2 ) {
-          UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
-          multiply->get_args().push_back( appExpr->get_args().front() );
-          multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
-          ret->get_args().push_back( multiply );
-          ret->get_args().push_back( appExpr->get_args().back() );
-        }
-        if( typeInst1 || typeInst2 ) {
-          ret->get_results().push_front( appExpr->get_results().front()->clone() );
-          if( appExpr->get_env() ) {
-            ret->set_env( appExpr->get_env() );
-            appExpr->set_env( 0 );
-          }
-          appExpr->get_args().clear();
-          delete appExpr;
-          return ret;
-        }
-      } else if( varExpr->get_var()->get_name() == "*?" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( !appExpr->get_args().empty() );
-        if( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
-          Expression *ret = appExpr->get_args().front();
-          delete ret->get_results().front();
-          ret->get_results().front() = appExpr->get_results().front()->clone();
-          if( appExpr->get_env() ) {
-            ret->set_env( appExpr->get_env() );
-            appExpr->set_env( 0 );
-          }
-          appExpr->get_args().clear();
-          delete appExpr;
-          return ret;
-        }
-      } else if( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( appExpr->get_args().size() == 1 );
-        if( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
-          Type *tempType = appExpr->get_results().front()->clone();
-          if( env ) {
-            env->apply( tempType );
-          }
-          ObjectDecl *newObj = makeTemporary( tempType );
-          VariableExpr *tempExpr = new VariableExpr( newObj );
-          UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
-          assignExpr->get_args().push_back( tempExpr->clone() );
-          if( AddressExpr *address = dynamic_cast< AddressExpr* >( appExpr->get_args().front() ) ) {
-            assignExpr->get_args().push_back( address->get_arg()->clone() );
-          } else {
-            assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
-          }
-          CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
-          return new CommaExpr( firstComma, tempExpr );
-        }
-      } else if( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( appExpr->get_args().size() == 1 );
-        if( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
-           return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
-        }
-      } else if( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( appExpr->get_args().size() == 2 );
-        TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
-        TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
-        if( typeInst1 && typeInst2 ) {
-          UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
-          divide->get_args().push_back( appExpr );
-          divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
-          divide->get_results().push_front( appExpr->get_results().front()->clone() );
-          if( appExpr->get_env() ) {
-            divide->set_env( appExpr->get_env() );
-            appExpr->set_env( 0 );
-          }
-          return divide;
-        } else if( typeInst1 ) {
-          UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
-          multiply->get_args().push_back( appExpr->get_args().back() );
-          multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
-          appExpr->get_args().back() = multiply;
-        } else if( typeInst2 ) {
-          UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
-          multiply->get_args().push_back( appExpr->get_args().front() );
-          multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
-          appExpr->get_args().front() = multiply;
-        }
-      } else if( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
-        assert( !appExpr->get_results().empty() );
-        assert( appExpr->get_args().size() == 2 );
-        TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
-        if( typeInst ) {
-          UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
-          multiply->get_args().push_back( appExpr->get_args().back() );
-          multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) );
-          appExpr->get_args().back() = multiply;
-        }
-      }
-      return appExpr;
-    }
-  }
-  return 0;
-}
-
-Expression*
-Pass1::mutate( ApplicationExpr *appExpr )
-{
+	    } // if
+	    return new VariableExpr( param );
+	}
+
+	void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) {
+	    UniqueName paramNamer( "_p" );
+	    for ( ; param != paramEnd; ++param, ++arg, ++realParam ) {
+		if ( (*param)->get_name() == "" ) {
+		    (*param)->set_name( paramNamer.newName() );
+		    (*param)->set_linkage( LinkageSpec::C );
+		} // if
+		adapteeApp->get_args().push_back( makeAdapterArg( *param, *arg, *realParam, tyVars ) );
+	    } // for
+	}
+
+	FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
+	    FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
+	    adapterType = ScrubTyVars::scrub( adapterType, tyVars );
+	    DeclarationWithType *adapteeDecl = adapterType->get_parameters().front();
+	    adapteeDecl->set_name( "_adaptee" );
+	    ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
+	    Statement *bodyStmt;
+  
+	    std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
+	    std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
+	    std::list< TypeDecl *>::iterator realTyParam = adaptee->get_forall().begin();
+	    for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
+		assert( tyArg != realType->get_forall().end() );
+		std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin();
+		std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin();
+		std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
+		for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
+		    assert( assertArg != (*tyArg)->get_assertions().end() );
+		    adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
+		} // for
+	    } // for
+  
+	    std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
+	    std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
+	    std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
+	    param++;		// skip adaptee parameter
+	    if ( realType->get_returnVals().empty() ) {
+		addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
+		bodyStmt = new ExprStmt( noLabels, adapteeApp );
+	    } else if ( isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+		if ( (*param)->get_name() == "" ) {
+		    (*param)->set_name( "_ret" );
+		    (*param)->set_linkage( LinkageSpec::C );
+		} // if
+		UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+		UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+		deref->get_args().push_back( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
+		assign->get_args().push_back( deref );
+		addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
+		assign->get_args().push_back( adapteeApp );
+		bodyStmt = new ExprStmt( noLabels, assign );
+	    } else {
+		// adapter for a function that returns a monomorphic value
+		addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
+		bodyStmt = new ReturnStmt( noLabels, adapteeApp );
+	    } // if
+	    CompoundStmt *adapterBody = new CompoundStmt( noLabels );
+	    adapterBody->get_kids().push_back( bodyStmt );
+	    return new FunctionDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
+	}
+
+	void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
+	    std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+	    std::list< FunctionType *> functions;
+	    for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+		for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+		    findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
+		} // for
+	    } // for
+	    for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
+		findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
+	    } // for
+	    std::set< std::string > adaptersDone;
+	    for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
+		FunctionType *realFunction = (*funType)->clone();
+		assert( env );
+		env->apply( realFunction );
+		std::string mangleName = SymTab::Mangler::mangle( realFunction );
+		if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
+		    std::map< std::string, FunctionDecl *>::iterator adapter = adapters.find( mangleName );
+		    if ( adapter == adapters.end() ) {
+			FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
+			adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
+			stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+		    } // if
+		    assert( adapter != adapters.end() );
+		    appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
+		    adaptersDone.insert( adaptersDone.begin(), mangleName );
+		} // if
+	    } // for
+	}
+
+	TypeInstType *isPolyPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
+	    if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+		return isPolyType( ptr->get_base(), env, tyVars );
+	    } else if ( env ) {
+		if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+		    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+			return isPolyPtr( newType, env, tyVars );
+		    } // if
+		} // if
+	    } // if
+	    return 0;
+	}
+
+	TypeInstType *isPolyPtrPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
+	    if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+		return isPolyPtr( ptr->get_base(), env, tyVars );
+	    } else if ( env ) {
+		if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+		    if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+			return isPolyPtrPtr( newType, env, tyVars );
+		    } // if
+		} // if
+	    } // if
+	    return 0;
+	}
+
+	Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr ) {
+	    NameExpr *opExpr;
+	    if ( isIncr ) {
+		opExpr = new NameExpr( "?+=?" );
+	    } else {
+		opExpr = new NameExpr( "?-=?" );
+	    } // if
+	    UntypedExpr *addAssign = new UntypedExpr( opExpr );
+	    if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
+		addAssign->get_args().push_back( address->get_arg() );
+	    } else {
+		addAssign->get_args().push_back( appExpr->get_args().front() );
+	    } // if
+	    addAssign->get_args().push_back( new NameExpr( polyName ) );
+	    addAssign->get_results().front() = appExpr->get_results().front()->clone();
+	    if ( appExpr->get_env() ) {
+		addAssign->set_env( appExpr->get_env() );
+		appExpr->set_env( 0 );
+	    } // if
+	    appExpr->get_args().clear();
+	    delete appExpr;
+	    return addAssign;
+	}
+
+	Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
+	    if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->get_function() ) ) {
+		if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
+		    if ( varExpr->get_var()->get_name() == "?[?]" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( appExpr->get_args().size() == 2 );
+			TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
+			TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
+			assert( !typeInst1 || !typeInst2 );
+			UntypedExpr *ret = 0;
+			if ( typeInst1 || typeInst2 ) {
+			    ret = new UntypedExpr( new NameExpr( "?+?" ) );
+			} // if
+			if ( typeInst1 ) {
+			    UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
+			    multiply->get_args().push_back( appExpr->get_args().back() );
+			    multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+			    ret->get_args().push_back( appExpr->get_args().front() );
+			    ret->get_args().push_back( multiply );
+			} else if ( typeInst2 ) {
+			    UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
+			    multiply->get_args().push_back( appExpr->get_args().front() );
+			    multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
+			    ret->get_args().push_back( multiply );
+			    ret->get_args().push_back( appExpr->get_args().back() );
+			} // if
+			if ( typeInst1 || typeInst2 ) {
+			    ret->get_results().push_front( appExpr->get_results().front()->clone() );
+			    if ( appExpr->get_env() ) {
+				ret->set_env( appExpr->get_env() );
+				appExpr->set_env( 0 );
+			    } // if
+			    appExpr->get_args().clear();
+			    delete appExpr;
+			    return ret;
+			} // if
+		    } else if ( varExpr->get_var()->get_name() == "*?" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( !appExpr->get_args().empty() );
+			if ( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
+			    Expression *ret = appExpr->get_args().front();
+			    delete ret->get_results().front();
+			    ret->get_results().front() = appExpr->get_results().front()->clone();
+			    if ( appExpr->get_env() ) {
+				ret->set_env( appExpr->get_env() );
+				appExpr->set_env( 0 );
+			    } // if
+			    appExpr->get_args().clear();
+			    delete appExpr;
+			    return ret;
+			} // if
+		    } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( appExpr->get_args().size() == 1 );
+			if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
+			    Type *tempType = appExpr->get_results().front()->clone();
+			    if ( env ) {
+				env->apply( tempType );
+			    } // if
+			    ObjectDecl *newObj = makeTemporary( tempType );
+			    VariableExpr *tempExpr = new VariableExpr( newObj );
+			    UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
+			    assignExpr->get_args().push_back( tempExpr->clone() );
+			    if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
+				assignExpr->get_args().push_back( address->get_arg()->clone() );
+			    } else {
+				assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
+			    } // if
+			    CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
+			    return new CommaExpr( firstComma, tempExpr );
+			} // if
+		    } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( appExpr->get_args().size() == 1 );
+			if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
+			    return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
+			} // if
+		    } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( appExpr->get_args().size() == 2 );
+			TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
+			TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
+			if ( typeInst1 && typeInst2 ) {
+			    UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
+			    divide->get_args().push_back( appExpr );
+			    divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+			    divide->get_results().push_front( appExpr->get_results().front()->clone() );
+			    if ( appExpr->get_env() ) {
+				divide->set_env( appExpr->get_env() );
+				appExpr->set_env( 0 );
+			    } // if
+			    return divide;
+			} else if ( typeInst1 ) {
+			    UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
+			    multiply->get_args().push_back( appExpr->get_args().back() );
+			    multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+			    appExpr->get_args().back() = multiply;
+			} else if ( typeInst2 ) {
+			    UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
+			    multiply->get_args().push_back( appExpr->get_args().front() );
+			    multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
+			    appExpr->get_args().front() = multiply;
+			} // if
+		    } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
+			assert( !appExpr->get_results().empty() );
+			assert( appExpr->get_args().size() == 2 );
+			TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
+			if ( typeInst ) {
+			    UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
+			    multiply->get_args().push_back( appExpr->get_args().back() );
+			    multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) );
+			    appExpr->get_args().back() = multiply;
+			} // if
+		    } // if
+		    return appExpr;
+		} // if
+	    } // if
+	    return 0;
+	}
+
+	Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
 ///     std::cerr << "mutate appExpr: ";
-///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
+///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 ///       std::cerr << i->first << " ";
 ///     }
 ///     std::cerr << "\n";
-  bool oldUseRetval = useRetval;
-  useRetval = false;
-  appExpr->get_function()->acceptMutator( *this );
-  mutateAll( appExpr->get_args(), *this );
-  useRetval = oldUseRetval;
-  
-  assert( !appExpr->get_function()->get_results().empty() );
-  PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
-  assert( pointer );
-  FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
-  assert( function );
-  
-  if( Expression *newExpr = handleIntrinsics( appExpr ) ) {
-    return newExpr;
-  }
-  
-  Expression *ret = appExpr;
-  
-  std::list< Expression* >::iterator arg = appExpr->get_args().begin();
-  std::list< Expression* >::iterator paramBegin = appExpr->get_args().begin();
-  
-  std::string typeName;
-  if( isPolyRet( function, typeName ) ) {
-    ret = addPolyRetParam( appExpr, function, typeName, arg );
-  } else if( needsAdapter( function, scopeTyVars ) ) {
+	    bool oldUseRetval = useRetval;
+	    useRetval = false;
+	    appExpr->get_function()->acceptMutator( *this );
+	    mutateAll( appExpr->get_args(), *this );
+	    useRetval = oldUseRetval;
+  
+	    assert( !appExpr->get_function()->get_results().empty() );
+	    PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+	    assert( pointer );
+	    FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+	    assert( function );
+  
+	    if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
+		return newExpr;
+	    } // if
+  
+	    Expression *ret = appExpr;
+  
+	    std::list< Expression *>::iterator arg = appExpr->get_args().begin();
+	    std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
+  
+	    std::string typeName;
+	    if ( isPolyRet( function, typeName ) ) {
+		ret = addPolyRetParam( appExpr, function, typeName, arg );
+	    } else if ( needsAdapter( function, scopeTyVars ) ) {
 ///     std::cerr << "needs adapter: ";
-///     for( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
+///     for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 ///       std::cerr << i->first << " ";
 ///     }
 ///     std::cerr << "\n";
-    // change the application so it calls the adapter rather than the passed function
-    ret = applyAdapter( appExpr, function, arg, scopeTyVars );
-  }
-  arg = appExpr->get_args().begin();
-  
-  TyVarMap exprTyVars;
-  makeTyVarMap( function, exprTyVars );
-  
-  passTypeVars( appExpr, arg, exprTyVars );
-  addInferredParams( appExpr, function, arg, exprTyVars );
-
-  arg = paramBegin;
-  
-  boxParams( appExpr, function, arg, exprTyVars );
-
-  passAdapters( appExpr, function, exprTyVars );
-
-  return ret;
-}
-
-Expression *
-Pass1::mutate( UntypedExpr *expr )
-{
-  if( !expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
-    if( NameExpr *name = dynamic_cast< NameExpr* >( expr->get_function() ) ) {
-      if( name->get_name() == "*?" ) {
-        Expression *ret = expr->get_args().front();
-        expr->get_args().clear();
-        delete expr;
-        return ret->acceptMutator( *this );
-      }
-    }
-  }
-  return PolyMutator::mutate( expr );
-}
-
-Expression *
-Pass1::mutate( AddressExpr *addrExpr )
-{
-  assert( !addrExpr->get_arg()->get_results().empty() );
-  mutateExpression( addrExpr->get_arg() );
-  if( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
-    Expression *ret = addrExpr->get_arg();
-    delete ret->get_results().front();
-    ret->get_results().front() = addrExpr->get_results().front()->clone();
-    addrExpr->set_arg( 0 );
-    delete addrExpr;
-    return ret;
-  } else {
-    return addrExpr;
-  }
-}
-
-Statement* 
-Pass1::mutate(ReturnStmt *retStmt)
-{
-  // a cast expr on a polymorphic return value is either redundant or invalid
-  while( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
-    retStmt->set_expr( castExpr->get_arg() );
-    retStmt->get_expr()->set_env( castExpr->get_env() );
-    castExpr->set_env( 0 );
-    castExpr->set_arg( 0 );
-    delete castExpr;
-  }
-  if( retval && retStmt->get_expr() ) {
-    assert( !retStmt->get_expr()->get_results().empty() );
-    if( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
+		// change the application so it calls the adapter rather than the passed function
+		ret = applyAdapter( appExpr, function, arg, scopeTyVars );
+	    } // if
+	    arg = appExpr->get_args().begin();
+  
+	    TyVarMap exprTyVars;
+	    makeTyVarMap( function, exprTyVars );
+  
+	    passTypeVars( appExpr, arg, exprTyVars );
+	    addInferredParams( appExpr, function, arg, exprTyVars );
+
+	    arg = paramBegin;
+  
+	    boxParams( appExpr, function, arg, exprTyVars );
+
+	    passAdapters( appExpr, function, exprTyVars );
+
+	    return ret;
+	}
+
+	Expression *Pass1::mutate( UntypedExpr *expr ) {
+	    if ( !expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
+		if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
+		    if ( name->get_name() == "*?" ) {
+			Expression *ret = expr->get_args().front();
+			expr->get_args().clear();
+			delete expr;
+			return ret->acceptMutator( *this );
+		    } // if
+		} // if
+	    } // if
+	    return PolyMutator::mutate( expr );
+	}
+
+	Expression *Pass1::mutate( AddressExpr *addrExpr ) {
+	    assert( !addrExpr->get_arg()->get_results().empty() );
+	    mutateExpression( addrExpr->get_arg() );
+	    if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
+		Expression *ret = addrExpr->get_arg();
+		delete ret->get_results().front();
+		ret->get_results().front() = addrExpr->get_results().front()->clone();
+		addrExpr->set_arg( 0 );
+		delete addrExpr;
+		return ret;
+	    } else {
+		return addrExpr;
+	    } // if
+	}
+
+	Statement *
+	Pass1::mutate(ReturnStmt *retStmt) {
+	    // a cast expr on a polymorphic return value is either redundant or invalid
+	    while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( retStmt->get_expr() ) ) {
+		retStmt->set_expr( castExpr->get_arg() );
+		retStmt->get_expr()->set_env( castExpr->get_env() );
+		castExpr->set_env( 0 );
+		castExpr->set_arg( 0 );
+		delete castExpr;
+	    }
+	    if ( retval && retStmt->get_expr() ) {
+		assert( !retStmt->get_expr()->get_results().empty() );
+		if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
 ///       retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
-      TypeInstType *typeInst = dynamic_cast< TypeInstType* >( retval->get_type() );
-      assert( typeInst );
-      std::map< std::string, DeclarationWithType* >::const_iterator assignIter = assignOps.find( typeInst->get_name() );
-      if( assignIter == assignOps.end() ) {
-        throw SemanticError( "Attempt to return dtype or ftype object in ", retStmt->get_expr() );
-      }
-      ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
-      Expression *retParm = new NameExpr( retval->get_name() );
-      retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
-      assignExpr->get_args().push_back( retParm );
-      assignExpr->get_args().push_back( retStmt->get_expr() );
-      stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
-    } else {
-      useRetval = true;
-      stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( retStmt->get_expr() ) ) );
-      useRetval = false;
-    }
-    retStmt->set_expr( 0 );
-  } else {
-    retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
-  }
-  return retStmt;
-}
-
-Type* 
-Pass1::mutate( PointerType *pointerType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( pointerType, scopeTyVars );
-  
-  Type* ret = Mutator::mutate( pointerType );
-  
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-Type* 
-Pass1::mutate( FunctionType *functionType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( functionType, scopeTyVars );
-  
-  Type* ret = Mutator::mutate( functionType );
-  
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-void
-Pass1::doEndScope()
-{
-  adapters.clear();
-}
+		    TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() );
+		    assert( typeInst );
+		    std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
+		    if ( assignIter == assignOps.end() ) {
+			throw SemanticError( "Attempt to return dtype or ftype object in ", retStmt->get_expr() );
+		    } // if
+		    ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+		    Expression *retParm = new NameExpr( retval->get_name() );
+		    retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
+		    assignExpr->get_args().push_back( retParm );
+		    assignExpr->get_args().push_back( retStmt->get_expr() );
+		    stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
+		} else {
+		    useRetval = true;
+		    stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( retStmt->get_expr() ) ) );
+		    useRetval = false;
+		} // if
+		retStmt->set_expr( 0 );
+	    } else {
+		retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
+	    } // if
+	    return retStmt;
+	}
+
+	Type *
+	Pass1::mutate( PointerType *pointerType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( pointerType, scopeTyVars );
+  
+	    Type *ret = Mutator::mutate( pointerType );
+  
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	Type *
+	Pass1::mutate( FunctionType *functionType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( functionType, scopeTyVars );
+  
+	    Type *ret = Mutator::mutate( functionType );
+  
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	void Pass1::doEndScope() {
+	    adapters.clear();
+	}
 
 ////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
 
-Pass2::Pass2()
-{
-}
-
-void 
-Pass2::addAdapters( FunctionType *functionType )
-{
-  std::list< DeclarationWithType* > &paramList = functionType->get_parameters();
-  std::list< FunctionType* > functions;
-  for( std::list< DeclarationWithType* >::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-    Type *orig = (*arg)->get_type();
-    findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
-    (*arg)->set_type( orig );
-  }
-  std::set< std::string > adaptersDone;
-  for( std::list< FunctionType* >::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-    std::string mangleName = SymTab::Mangler::mangle( *funType );
-    if( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-      paramList.push_front( new ObjectDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
-      adaptersDone.insert( adaptersDone.begin(), mangleName );
-    }
-  }
+	Pass2::Pass2() {}
+
+	void Pass2::addAdapters( FunctionType *functionType ) {
+	    std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+	    std::list< FunctionType *> functions;
+	    for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
+		Type *orig = (*arg)->get_type();
+		findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
+		(*arg)->set_type( orig );
+	    }
+	    std::set< std::string > adaptersDone;
+	    for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
+		std::string mangleName = SymTab::Mangler::mangle( *funType );
+		if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
+		    paramList.push_front( new ObjectDecl( "_adapter" + mangleName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
+		    adaptersDone.insert( adaptersDone.begin(), mangleName );
+		}
+	    }
 ///  deleteAll( functions );
-}
-
-template< typename DeclClass >
-DeclClass* 
-Pass2::handleDecl( DeclClass *decl, Type *type )
-{
-  DeclClass *ret = static_cast< DeclClass* >( Mutator::mutate( decl ) );
-
-  return ret;
-}
-
-DeclarationWithType* 
-Pass2::mutate( FunctionDecl *functionDecl )
-{
-  return handleDecl( functionDecl, functionDecl->get_functionType() );
-}
-
-ObjectDecl* 
-Pass2::mutate( ObjectDecl *objectDecl )
-{
-  return handleDecl( objectDecl, objectDecl->get_type() );
-}
-
-TypeDecl* 
-Pass2::mutate( TypeDecl *typeDecl )
-{
-  scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-  if( typeDecl->get_base() ) {
-    return handleDecl( typeDecl, typeDecl->get_base() );
-  } else {
-    return Mutator::mutate( typeDecl );
-  }
-}
-
-TypedefDecl* 
-Pass2::mutate( TypedefDecl *typedefDecl )
-{
-  return handleDecl( typedefDecl, typedefDecl->get_base() );
-}
-
-Type* 
-Pass2::mutate( PointerType *pointerType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( pointerType, scopeTyVars );
-  
-  Type* ret = Mutator::mutate( pointerType );
-  
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-Type *
-Pass2::mutate( FunctionType *funcType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( funcType, scopeTyVars );
-  
-  std::string typeName;
-  if( isPolyRet( funcType, typeName ) ) {
-    DeclarationWithType *ret = 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();
-  }
-  
-  std::list< DeclarationWithType* >::iterator last = funcType->get_parameters().begin();
-  std::list< DeclarationWithType* > inferredParams;
-  ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+	}
+
+	template< typename DeclClass >
+	DeclClass *
+	Pass2::handleDecl( DeclClass *decl, Type *type ) {
+	    DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+
+	    return ret;
+	}
+
+	DeclarationWithType *
+	Pass2::mutate( FunctionDecl *functionDecl ) {
+	    return handleDecl( functionDecl, functionDecl->get_functionType() );
+	}
+
+	ObjectDecl *
+	Pass2::mutate( ObjectDecl *objectDecl ) {
+	    return handleDecl( objectDecl, objectDecl->get_type() );
+	}
+
+	TypeDecl *
+	Pass2::mutate( TypeDecl *typeDecl ) {
+	    scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
+	    if ( typeDecl->get_base() ) {
+		return handleDecl( typeDecl, typeDecl->get_base() );
+	    } else {
+		return Mutator::mutate( typeDecl );
+	    }
+	}
+
+	TypedefDecl *
+	Pass2::mutate( TypedefDecl *typedefDecl ) {
+	    return handleDecl( typedefDecl, typedefDecl->get_base() );
+	}
+
+	Type *
+	Pass2::mutate( PointerType *pointerType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( pointerType, scopeTyVars );
+  
+	    Type *ret = Mutator::mutate( pointerType );
+  
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	Type *Pass2::mutate( FunctionType *funcType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( funcType, scopeTyVars );
+  
+	    std::string typeName;
+	    if ( isPolyRet( funcType, typeName ) ) {
+		DeclarationWithType *ret = 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();
+	    }
+  
+	    std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
+	    std::list< DeclarationWithType *> inferredParams;
+	    ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
 ///   ObjectDecl *newFunPtr = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
-  for( std::list< TypeDecl* >::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
-    ObjectDecl *thisParm;
-    if( (*tyParm)->get_kind() == TypeDecl::Any ) {
-      thisParm = newObj->clone();
-      thisParm->set_name( (*tyParm)->get_name() );
-      last = funcType->get_parameters().insert( last, thisParm );
-      ++last;
-    }
-    for( std::list< DeclarationWithType* >::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-///       *assert = (*assert)->acceptMutator( *this );
-      inferredParams.push_back( *assert );
-    }
-    (*tyParm)->get_assertions().clear();
-  }
-  delete newObj;
-  funcType->get_parameters().splice( last, inferredParams );
-  addAdapters( funcType );
-  mutateAll( funcType->get_returnVals(), *this );
-  mutateAll( funcType->get_parameters(), *this );
-  
-  scopeTyVars = oldtyVars;
-  return funcType;
-}
+	    for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
+		ObjectDecl *thisParm;
+		if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
+		    thisParm = newObj->clone();
+		    thisParm->set_name( (*tyParm)->get_name() );
+		    last = funcType->get_parameters().insert( last, thisParm );
+		    ++last;
+		}
+		for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
+///      *assert = (*assert)->acceptMutator( *this );
+		    inferredParams.push_back( *assert );
+		}
+		(*tyParm)->get_assertions().clear();
+	    }
+	    delete newObj;
+	    funcType->get_parameters().splice( last, inferredParams );
+	    addAdapters( funcType );
+	    mutateAll( funcType->get_returnVals(), *this );
+	    mutateAll( funcType->get_parameters(), *this );
+  
+	    scopeTyVars = oldtyVars;
+	    return funcType;
+	}
 
 ////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
 
-template< typename DeclClass >
-DeclClass* 
-Pass3::handleDecl( DeclClass *decl, Type *type )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( type, scopeTyVars );
-  
-  DeclClass *ret = static_cast< DeclClass* >( Mutator::mutate( decl ) );
-  ScrubTyVars::scrub( decl, scopeTyVars );
-
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-ObjectDecl* 
-Pass3::mutate( ObjectDecl *objectDecl )
-{
-  return handleDecl( objectDecl, objectDecl->get_type() );
-}
-
-DeclarationWithType* 
-Pass3::mutate( FunctionDecl *functionDecl )
-{
-  return handleDecl( functionDecl, functionDecl->get_functionType() );
-}
-
-TypedefDecl* 
-Pass3::mutate( TypedefDecl *typedefDecl )
-{
-  return handleDecl( typedefDecl, typedefDecl->get_base() );
-}
-
-TypeDecl* 
-Pass3::mutate( TypeDecl *typeDecl )
-{
+	template< typename DeclClass >
+	DeclClass *
+	Pass3::handleDecl( DeclClass *decl, Type *type ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( type, scopeTyVars );
+  
+	    DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+	    ScrubTyVars::scrub( decl, scopeTyVars );
+
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	ObjectDecl *
+	Pass3::mutate( ObjectDecl *objectDecl ) {
+	    return handleDecl( objectDecl, objectDecl->get_type() );
+	}
+
+	DeclarationWithType *
+	Pass3::mutate( FunctionDecl *functionDecl ) {
+	    return handleDecl( functionDecl, functionDecl->get_functionType() );
+	}
+
+	TypedefDecl *
+	Pass3::mutate( TypedefDecl *typedefDecl ) {
+	    return handleDecl( typedefDecl, typedefDecl->get_base() );
+	}
+
+	TypeDecl *
+	Pass3::mutate( TypeDecl *typeDecl ) {
 ///   Initializer *init = 0;
 ///   std::list< Expression *> designators;
 ///   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-///   if( typeDecl->get_base() ) {
+///   if ( typeDecl->get_base() ) {
 ///     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
 ///   }
 ///   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
 
-  scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-  return Mutator::mutate( typeDecl );
-}
-
-Type* 
-Pass3::mutate( PointerType *pointerType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( pointerType, scopeTyVars );
-  
-  Type* ret = Mutator::mutate( pointerType );
-  
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-Type* 
-Pass3::mutate( FunctionType *functionType )
-{
-  TyVarMap oldtyVars = scopeTyVars;
-  makeTyVarMap( functionType, scopeTyVars );
-  
-  Type* ret = Mutator::mutate( functionType );
-  
-  scopeTyVars = oldtyVars;
-  return ret;
-}
-
-Statement*
-Pass3::mutate( DeclStmt *declStmt )
-{
-  if( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( declStmt->get_decl() ) ) {
-    if( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
-      TypeInstType *typeInst = dynamic_cast< TypeInstType* >( objectDecl->get_type() );
-      assert( typeInst );
-      UntypedExpr *alloc = new UntypedExpr( new NameExpr( "alloca" ) );
-      alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
-      UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-      assign->get_args().push_back( new VariableExpr( objectDecl ) );
-      assign->get_args().push_back( alloc );
-      stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
-    }
-  }
-  return Mutator::mutate( declStmt );
-}
+	    scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
+	    return Mutator::mutate( typeDecl );
+	}
+
+	Type *
+	Pass3::mutate( PointerType *pointerType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( pointerType, scopeTyVars );
+  
+	    Type *ret = Mutator::mutate( pointerType );
+  
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	Type *
+	Pass3::mutate( FunctionType *functionType ) {
+	    TyVarMap oldtyVars = scopeTyVars;
+	    makeTyVarMap( functionType, scopeTyVars );
+  
+	    Type *ret = Mutator::mutate( functionType );
+  
+	    scopeTyVars = oldtyVars;
+	    return ret;
+	}
+
+	Statement *Pass3::mutate( DeclStmt *declStmt ) {
+	    if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
+		if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
+		    TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
+		    assert( typeInst );
+		    UntypedExpr *alloc = new UntypedExpr( new NameExpr( "alloca" ) );
+		    alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
+		    UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+		    assign->get_args().push_back( new VariableExpr( objectDecl ) );
+		    assign->get_args().push_back( alloc );
+		    stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
+		}
+	    }
+	    return Mutator::mutate( declStmt );
+	}
     
-} // anonymous namespace
+    } // anonymous namespace
 
 } // namespace GenPoly