Changeset e0e9a0b for src/ResolvExpr

Timestamp:

Jun 27, 2019, 5:16:54 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

7d0881c

Parents:

6be3b7d6

Message:

Somewhat deeper clone for types with forall qualifiers.

• Added WithForallSubstitutor? pass accessory to perform these changes
• modified copy constructors of ParameterizedType? to properly update children

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (2 diffs)
• RenameVars.cc (modified) (10 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -548 +548 @@
                 genStart = genEnd;
 
-                return genEnd != results.size();
+                return genEnd != results.size();  // were any new results added?
         }
 
@@ -677 +677 @@
                         ast::TypeEnvironment funcEnv{ func->env };
                         makeUnifiableVars( funcType, funcOpen, funcNeed );
-                        // add all type variables as open variables now so that those not used in the parameter 
-                        // list are still considered open
+                        // add all type variables as open variables now so that those not used in the 
+                        // parameter list are still considered open
                         funcEnv.add( funcType->forall );
 

src/ResolvExpr/RenameVars.cc

@@ -19 +19 @@
 #include <utility>                 // for pair
 
+#include "AST/ForallSubstitutionTable.hpp"
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
@@ -37 +38 @@
                 int resetCount = 0;
                 ScopedMap< std::string, std::string > nameMap;
+        public:
+                ast::ForallSubstitutionTable subs;
 
-        public:
                 void reset() {
                         level = 0;
@@ -44 +46 @@
                 }
 
-                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;
@@ -65 +65 @@
                                         // ditto for assertion names, the next level in
                                         level++;
-                                        // acceptAll( td->assertions, *this );
-                                } // for
-                        } // if
+                                }
+                        }
                 }
 
@@ -77 +76 @@
 
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
-                        mapConstIterator it = nameMap.find( type->name );
+                        // re-linking of base type handled by WithForallSubstitutor
+
+                        // rename
+                        auto it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
-                                ast::TypeInstType * mutType = ast::mutate( type );
-                                mutType->name = it->second;
-                    type = mutType;
+                                // unconditionally mutate because map will *always* have different name, 
+                                // if this mutates, will *always* have been mutated by ForallSubstitutor above
+                                ast::TypeInstType * mut = ast::mutate( type );
+                                mut->name = it->second;
+                    type = mut;
                         }
+
                         return type;
                 }
@@ -88 +93 @@
                 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;
+                        if ( type->forall.empty() ) return type;
+                        
+                        nameMap.beginScope();
 
-                                        ast::TypeDecl * decl = ast::mutate( td.get() );
-                                        decl->name = newname;
-                                        td = decl;
-                                }
+                        // Load new names from this forall clause and perform renaming.
+                        NodeT * mutType = ast::mutate( type );
+                        assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        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 * mutDecl = ast::mutate( td.get() );
+                                assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+                                mutDecl->name = newname;
+                                // assertion above means `td = mutDecl;` is unnecessary
                         }
+                        // assertion above means `type = mutType;` is unnecessary
+
                         return type;
                 }
 
-                template<typename NodeT>
-                const NodeT * closeLevel( const NodeT * type ) {
-                        if ( !type->forall.empty() ) {
-                                nameMap.endScope();
-                        }
-                        return type;
+                void closeLevel( const ast::ParameterizedType * type ) {
+                        if ( type->forall.empty() ) return;
+                        
+                        nameMap.endScope();
                 }
         };
@@ -119 +127 @@
         RenamingData renaming;
 
-        struct RenameVars {
+        struct RenameVars_old {
                 void previsit( TypeInstType * instType ) {
                         renaming.openLevel( (Type*)instType );
@@ -130 +138 @@
                         renaming.closeLevel( type );
                 }
+        };
+        
+        struct RenameVars_new /*: public ast::WithForallSubstitutor*/ {
+                #warning when old RenameVars goes away, replace hack below with global pass inheriting from WithForallSubstitutor
+                ast::ForallSubstitutionTable & subs = renaming.subs;
 
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
@@ -146 +159 @@
                         return renaming.rename( renaming.openLevel( type ) );
                 }
-                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
-                        return renaming.closeLevel( type );
+                void postvisit( const ast::ParameterizedType * type ) {
+                        renaming.closeLevel( type );
                 }
         };
@@ -154 +167 @@
 
 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;
+        ast::Pass<RenameVars_new> renamer;
         return t->accept( renamer );
 }