Changeset 58fe85a for src/ResolvExpr/RenameVars.cc

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (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 'master' into park_unpark

File:

• src/ResolvExpr/RenameVars.cc (modified) (10 diffs)

src/ResolvExpr/RenameVars.cc

@@ -30 +30 @@
 #include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
 
+#include "AST/Copy.hpp"
+
 namespace ResolvExpr {
 
@@ -36 +38 @@
                 int level = 0;
                 int resetCount = 0;
+
+                int next_expr_id = 1;
+                int next_usage_id = 1;
                 ScopedMap< std::string, std::string > nameMap;
-
+                ScopedMap< std::string, ast::TypeInstType::TypeEnvKey > idMap;
         public:
                 void reset() {
@@ -44 +49 @@
                 }
 
-                using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator;
-
                 void rename( TypeInstType * type ) {
-                        mapConstIterator it = nameMap.find( type->name );
+                        auto it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
                                 type->name = it->second;
                         }
+                }
+
+                void nextUsage() {
+                        ++next_usage_id;
                 }
 
@@ -65 +72 @@
                                         // ditto for assertion names, the next level in
                                         level++;
-                                        // acceptAll( td->assertions, *this );
-                                } // for
-                        } // if
+                                }
+                        }
                 }
 
@@ -77 +83 @@
 
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
-                        mapConstIterator it = nameMap.find( type->name );
-                        if ( it != nameMap.end() ) {
-                                ast::TypeInstType * mutType = ast::mutate( type );
-                                mutType->name = it->second;
-                    type = mutType;
-                        }
+                        // rename
+                        auto it = idMap.find( type->name );
+                        if ( it != idMap.end() ) {
+                                // unconditionally mutate because map will *always* have different name
+                                ast::TypeInstType * mut = ast::shallowCopy( type );
+                                // reconcile base node since some copies might have been made
+                                mut->base = it->second.base;
+                                mut->formal_usage = it->second.formal_usage;
+                                mut->expr_id = it->second.expr_id;
+                    type = mut;
+                        }
+
                         return type;
                 }
 
-                template<typename NodeT>
-                const NodeT * openLevel( const NodeT * type ) {
-                        if ( !type->forall.empty() ) {
-                                nameMap.beginScope();
-                                // Load new names from this forall clause and perform renaming.
-                                NodeT * mutType = ast::mutate( type );
-                                for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
-                                        std::ostringstream output;
-                                        output << "_" << resetCount << "_" << level << "_" << td->name;
-                                        std::string newname( output.str() );
-                                        nameMap[ td->name ] = newname;
-                                        ++level;
-
-                                        ast::TypeDecl * decl = ast::mutate( td.get() );
-                                        decl->name = newname;
-                                        td = decl;
-                                }
-                        }
-                        return type;
-                }
-
-                template<typename NodeT>
-                const NodeT * closeLevel( const NodeT * type ) {
-                        if ( !type->forall.empty() ) {
-                                nameMap.endScope();
-                        }
-                        return type;
+                const ast::FunctionType * openLevel( const ast::FunctionType * type, RenameMode mode ) {
+                        if ( type->forall.empty() ) return type;
+                        idMap.beginScope();
+
+                        // Load new names from this forall clause and perform renaming.
+                        auto mutType = ast::shallowCopy( type );
+                        // assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        for ( auto & td : mutType->forall ) {
+                                auto mut = ast::shallowCopy( td.get() );
+                                // assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+
+                                if (mode == GEN_EXPR_ID) {
+                                        mut->expr_id = next_expr_id;
+                                        mut->formal_usage = -1;
+                                        ++next_expr_id;
+                                }
+                                else if (mode == GEN_USAGE) {
+                                        assertf(mut->expr_id, "unfilled expression id in generating candidate type");
+                                        mut->formal_usage = next_usage_id;
+                                }
+                                else {
+                                        assert(false);
+                                }
+                                idMap[ td->name ] = ast::TypeInstType::TypeEnvKey(*mut);
+                                
+                                td = mut;
+                        }
+
+                        return mutType;
+                }
+
+                void closeLevel( const ast::FunctionType * type ) {
+                        if ( type->forall.empty() ) return;
+                        idMap.endScope();
                 }
         };
@@ -119 +138 @@
         RenamingData renaming;
 
-        struct RenameVars {
+        struct RenameVars_old {
                 void previsit( TypeInstType * instType ) {
                         renaming.openLevel( (Type*)instType );
@@ -130 +149 @@
                         renaming.closeLevel( type );
                 }
+        };
+
+        struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
+                RenameMode mode;
 
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
-                        return renaming.openLevel( type );
-                }
+                        return renaming.openLevel( type, mode );
+                }
+
+                /*
                 const ast::StructInstType * previsit( const ast::StructInstType * type ) {
                         return renaming.openLevel( type );
@@ -143 +168 @@
                         return renaming.openLevel( type );
                 }
+                */
+
                 const ast::TypeInstType * previsit( const ast::TypeInstType * type ) {
-                        return renaming.rename( renaming.openLevel( type ) );
-                }
-                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
-                        return renaming.closeLevel( type );
+                        if (mode == GEN_USAGE && !type->formal_usage) return type; // do not rename an actual type
+                        return renaming.rename( type );
+                }
+                void postvisit( const ast::FunctionType * type ) {
+                        renaming.closeLevel( type );
                 }
         };
@@ -154 +182 @@
 
 void renameTyVars( Type * t ) {
-        PassVisitor<RenameVars> renamer;
+        PassVisitor<RenameVars_old> renamer;
         t->accept( renamer );
 }
 
-const ast::Type * renameTyVars( const ast::Type * t ) {
-        ast::Pass<RenameVars> renamer;
+const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
+        // ast::Type *tc = ast::deepCopy(t);
+        ast::Pass<RenameVars_new> renamer;
+        renamer.core.mode = mode;
+        if (mode == GEN_USAGE && reset) {
+                renaming.nextUsage();
+        }
         return t->accept( renamer );
 }
@@ -165 +198 @@
 void resetTyVarRenaming() {
         renaming.reset();
+        renaming.nextUsage();
 }