Changeset f57dd25 for src/SynTree

Timestamp:

May 29, 2019, 3:45:00 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

0aedb01

Parents:

157a816 (diff), ebc0a85 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'cleanup-dtors'

Location:

src/SynTree

Files:

• DeclReplacer.cc (modified) (3 diffs)
• DeclReplacer.h (modified) (1 diff)
• Expression.cc (modified) (3 diffs)
• Expression.h (modified) (1 diff)

src/SynTree/DeclReplacer.cc

@@ -38 +38 @@
                         void previsit( TypeInstType * inst );
                 };
+
+                /// Mutator that replaces uses of declarations with arbitrary expressions, according to the supplied mapping
+                struct ExprDeclReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        bool debug;
+                public:
+                        ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
+
+                        // replace variable with new node from expr map
+                        Expression * postmutate( VariableExpr * varExpr );
+                };
         }
 
@@ -53 +65 @@
                 DeclMap declMap;
                 replace( node, declMap, typeMap, debug );
+        }
+
+        void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
+                PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
+                node = maybeMutate( node, replacer );
         }
 
@@ -79 +96 @@
                         }
                 }
+
+                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ) {}
+
+                Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
+                        if ( exprMap.count( varExpr->var ) ) {
+                                Expression * replacement = exprMap.at( varExpr->var )->clone();
+                                if ( debug ) {
+                                        std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)replacement << " " << replacement << std::endl;
+                                }
+                                std::swap( varExpr->env, replacement->env );
+                                delete varExpr;
+                                return replacement;
+                        }
+                        return varExpr;
+                }
         }
 } // namespace VarExprReplacer

src/SynTree/DeclReplacer.h

@@ -26 +26 @@
         typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
         typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
+        typedef std::map< DeclarationWithType *, Expression * > ExprMap;
 
         void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
         void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
         void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+
+        void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
+        template<typename T>
+                void replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
+                if ( ! node ) return;
+                BaseSyntaxNode * arg = node;
+                replace( arg, exprMap, debug );
+                node = dynamic_cast<T *>( arg );
+                assertf( node, "DeclReplacer fundamentally changed the type of its argument." );
+        }
 }
 

src/SynTree/Expression.cc

@@ -538 +538 @@
         assert( callExpr );
         assert( callExpr->result );
-        set_result( callExpr->get_result()->clone() );
+        set_result( callExpr->result->clone() );
 }
 
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
-        cloneAll( other.tempDecls, tempDecls );
-        cloneAll( other.returnDecls, returnDecls );
-        cloneAll( other.dtors, dtors );
 }
 
@@ -550 +547 @@
         set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
         delete callExpr;
-        deleteAll( tempDecls );
-        deleteAll( returnDecls );
-        deleteAll( dtors );
 }
 
@@ -558 +552 @@
         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent+1 );
-        os << std::endl << indent << "... with temporaries:" << std::endl;
-        printAll( tempDecls, os, indent+1 );
-        os << std::endl << indent << "... with return temporaries:" << std::endl;
-        printAll( returnDecls, os, indent+1 );
-        Expression::print( os, indent );
 }
 

src/SynTree/Expression.h

@@ -593 +593 @@
 class ImplicitCopyCtorExpr : public Expression {
 public:
-        ApplicationExpr * callExpr;
-        std::list< ObjectDecl * > tempDecls;
-        std::list< ObjectDecl * > returnDecls;
-        std::list< Expression * > dtors;
+        ApplicationExpr * callExpr = nullptr;
 
         ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
         ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
         virtual ~ImplicitCopyCtorExpr();
-
-        ApplicationExpr * get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
-
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
 
         virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }