Changes in src/GenPoly/Specialize.cc [fc72845d:ae4038d]

File:

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

src/GenPoly/Specialize.cc

@@ -14 +14 @@
 //
 
-#include <cassert>                       // for assert, assertf
-#include <iterator>                      // for back_insert_iterator, back_i...
-#include <map>                           // for _Rb_tree_iterator, _Rb_tree_...
-#include <memory>                        // for unique_ptr
-#include <string>                        // for string
-#include <tuple>                         // for get
-#include <utility>                       // for pair
-
-#include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"        // for SemanticError
-#include "Common/UniqueName.h"           // for UniqueName
-#include "Common/utility.h"              // for group_iterate
-#include "GenPoly.h"                     // for getFunctionType
-#include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
-#include "Parser/LinkageSpec.h"          // for C
-#include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
-#include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
+#include <cassert>
+
 #include "Specialize.h"
-#include "SynTree/Attribute.h"           // for Attribute
-#include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...
-#include "SynTree/Expression.h"          // for ApplicationExpr, Expression
-#include "SynTree/Label.h"               // for Label, noLabels
-#include "SynTree/Mutator.h"             // for mutateAll
-#include "SynTree/Statement.h"           // for CompoundStmt, DeclStmt, Expr...
-#include "SynTree/Type.h"                // for FunctionType, TupleType, Type
-#include "SynTree/TypeSubstitution.h"    // for TypeSubstitution
-#include "SynTree/Visitor.h"             // for Visitor
+#include "GenPoly.h"
+#include "PolyMutator.h"
+
+#include "Parser/ParseNode.h"
+
+#include "SynTree/Expression.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+#include "SynTree/Attribute.h"
+#include "SynTree/TypeSubstitution.h"
+#include "SynTree/Mutator.h"
+#include "ResolvExpr/FindOpenVars.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
+#include "Tuples/Tuples.h"
 
 namespace GenPoly {
-        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
-                Expression * postmutate( ApplicationExpr *applicationExpr );
-                Expression * postmutate( AddressExpr *castExpr );
-                Expression * postmutate( CastExpr *castExpr );
+        class Specialize final : public PolyMutator {
+          public:
+                using PolyMutator::mutate;
+                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+                virtual Expression * mutate( AddressExpr *castExpr ) override;
+                virtual Expression * mutate( CastExpr *castExpr ) override;
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
 
                 void handleExplicitParams( ApplicationExpr *appExpr );
@@ -126 +123 @@
                         // conversion of 0 (null) to function type does not require tuple specialization
                         if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
-                        FunctionType * aftype = getFunctionType( actualType->stripReferences() );
-                        assertf( aftype, "formal type is a function type, but actual type is not: %s", toString( actualType ).c_str() );
+                        FunctionType * aftype = getFunctionType( actualType );
+                        assertf( aftype, "formal type is a function type, but actual type is not." );
                         // Can't tuple specialize if parameter sizes deeply-differ.
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
@@ -199 +196 @@
         }
 
-        struct EnvTrimmer {
+        struct EnvTrimmer : public Visitor {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( TypeDecl * tyDecl ) {
+                virtual void visit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
-                        if ( Type * t = env->lookup( tyDecl->name ) ) {
-                                newEnv->add( tyDecl->name, t );
+                        if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
+                                newEnv->add( tyDecl->get_name(), t );
                         }
                 }
@@ -214 +211 @@
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
-                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
+                        EnvTrimmer trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
@@ -272 +269 @@
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
-                // save stmtsToAddBefore in oldStmts
+                // save stmtsToAdd in oldStmts
                 std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
-                appExpr->acceptMutator( *visitor );
+                oldStmts.splice( oldStmts.end(), stmtsToAdd );
+                mutate( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
-                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
-                // restore oldStmts into stmtsToAddBefore
-                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
+                thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
+                // restore oldStmts into stmtsToAdd
+                stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
 
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
-                if ( funType->returnVals.empty() ) {
+                if ( funType->get_returnVals().empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
-                thunkFunc->statements->kids.push_back( appStmt );
+                thunkFunc->get_statements()->get_kids().push_back( appStmt );
 
                 // add thunk definition to queue of statements to add
-                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
@@ -299 +296 @@
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
-                assert( appExpr->function->result );
-                FunctionType *function = getFunctionType( appExpr->function->result );
+                assert( appExpr->get_function()->has_result() );
+                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
-                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
-                }
-        }
-
-        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+
+        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
+                appExpr->get_function()->acceptMutator( *this );
+                mutateAll( appExpr->get_args(), *this );
+
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
@@ -323 +323 @@
         }
 
-        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
-                assert( addrExpr->result );
-                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
+        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
+                addrExpr->get_arg()->acceptMutator( *this );
+                assert( addrExpr->has_result() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
 
-        Expression * Specialize::postmutate( CastExpr *castExpr ) {
-                if ( castExpr->result->isVoid() ) {
+        Expression * Specialize::mutate( CastExpr *castExpr ) {
+                castExpr->get_arg()->acceptMutator( *this );
+                if ( castExpr->get_result()->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
-                if ( specialized != castExpr->arg ) {
+                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
@@ -343 +345 @@
         }
 
+        // Removing these for now. Richard put these in for some reason, but it's not clear why.
+        // In particular, copy constructors produce a comma expression, and with this code the parts
+        // of that comma expression are not specialized, which causes problems.
+
+        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
+        //      return logicalExpr;
+        // }
+
+        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
+        //      return condExpr;
+        // }
+
+        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
+        //      return commaExpr;
+        // }
+
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                PassVisitor<Specialize> spec;
+                Specialize spec;
                 mutateAll( translationUnit, spec );
         }