Changeset eb5962a for src/AST

Timestamp:

Jun 21, 2022, 1:39:24 PM (23 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

b62d1d6

Parents:

1df492a (diff), 1dbbef6 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

• Pass.impl.hpp (modified) (5 diffs)
• TypeSubstitution.cpp (modified) (4 diffs)
• TypeSubstitution.hpp (modified) (3 diffs)

src/AST/Pass.impl.hpp

@@ -182 +182 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
-                auto decls_before = __pass::declsToAddBefore( core, 0);
-                auto decls_after  = __pass::declsToAddAfter ( core, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+                auto decls_before = __pass::declsToAddBefore( core, 0 );
+                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -287 +287 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
-                auto decls_before = __pass::declsToAddBefore( core, 0);
-                auto decls_after  = __pass::declsToAddAfter ( core, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+                auto decls_before = __pass::declsToAddBefore( core, 0 );
+                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -317 +317 @@
                                 assert(( empty( stmts_before ) && empty( stmts_after ))
                                     || ( empty( decls_before ) && empty( decls_after )) );
-
-
 
                                 // Take all the statements which should have gone after, N/A for first iteration
@@ -2116 +2114 @@
         if ( __visit_children() ) {
                 bool mutated = false;
-                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
-                for ( const auto & p : node->typeEnv ) {
+                ast::TypeSubstitution::TypeMap new_map;
+                for ( const auto & p : node->typeMap ) {
                         guard_symtab guard { *this };
                         auto new_node = p.second->accept( *this );
@@ -2125 +2123 @@
                 if (mutated) {
                         auto new_node = __pass::mutate<core_t>( node );
-                        new_node->typeEnv.swap( new_map );
+                        new_node->typeMap.swap( new_map );
                         node = new_node;
                 }

src/AST/TypeSubstitution.cpp

@@ -38 +38 @@
 
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
-        dest.typeEnv.clear();
+        dest.typeMap.clear();
         dest.add( src );
 }
 
 void TypeSubstitution::add( const TypeSubstitution &other ) {
-        for ( TypeEnvType::const_iterator i = other.typeEnv.begin(); i != other.typeEnv.end(); ++i ) {
-                typeEnv[ i->first ] = i->second;
+        for ( TypeMap::const_iterator i = other.typeMap.begin(); i != other.typeMap.end(); ++i ) {
+                typeMap[ i->first ] = i->second;
         } // for
 }
 
 void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
-        typeEnv[ *formalType ] = actualType;
+        typeMap[ *formalType ] = actualType;
 }
 
 void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
-        typeEnv[ key ] = actualType;
+        typeMap[ key ] = actualType;
 }
 
 void TypeSubstitution::remove( const TypeInstType * formalType ) {
-        TypeEnvType::iterator i = typeEnv.find( *formalType );
-        if ( i != typeEnv.end() ) {
-                typeEnv.erase( *formalType );
-        } // if
-}
-
-const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
-        TypeEnvType::const_iterator i = typeEnv.find( *formalType );
+        TypeMap::iterator i = typeMap.find( *formalType );
+        if ( i != typeMap.end() ) {
+                typeMap.erase( *formalType );
+        } // if
+}
+
+const Type *TypeSubstitution::lookup(
+                const TypeInstType::TypeEnvKey & formalType ) const {
+        TypeMap::const_iterator i = typeMap.find( formalType );
 
         // break on not in substitution set
-        if ( i == typeEnv.end() ) return 0;
+        if ( i == typeMap.end() ) return 0;
 
         // attempt to transitively follow TypeInstType links.
         while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
                 // break cycles in the transitive follow
-                if ( *formalType == *actualType ) break;
+                if ( formalType == *actualType ) break;
 
                 // Look for the type this maps to, returning previous mapping if none-such
-                i = typeEnv.find( *actualType );
-                if ( i == typeEnv.end() ) return actualType;
+                i = typeMap.find( *actualType );
+                if ( i == typeMap.end() ) return actualType;
         }
 
@@ -83 +84 @@
 }
 
+const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
+        return lookup( ast::TypeInstType::TypeEnvKey( *formalType ) );
+}
+
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty();
+        return typeMap.empty();
 }
 
@@ -119 +124 @@
                 sub.core.subCount = 0;
                 sub.core.freeOnly = true;
-                for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+                for ( TypeMap::iterator i = typeMap.begin(); i != typeMap.end(); ++i ) {
                         i->second = i->second->accept( sub );
                 }
@@ -129 +134 @@
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
-        if ( i == sub.typeEnv.end() ) {
+        TypeMap::const_iterator i = sub.typeMap.find( *inst );
+        if ( i == sub.typeMap.end() ) {
                 return inst;
         } else {

src/AST/TypeSubstitution.hpp

@@ -75 +75 @@
         void add( const TypeSubstitution &other );
         void remove( const TypeInstType * formalType );
+        const Type *lookup( const TypeInstType::TypeEnvKey & formalType ) const;
         const Type *lookup( const TypeInstType * formalType ) const;
         bool empty() const;
@@ -104 +105 @@
         friend class Pass;
 
-        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
-        TypeEnvType typeEnv;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeMap;
+        TypeMap typeMap;
 
   public:
-        // has to come after declaration of typeEnv
-        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
-        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
-        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
-        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        // has to come after declaration of typeMap
+        auto begin()       -> decltype( typeMap.begin() ) { return typeMap.begin(); }
+        auto   end()       -> decltype( typeMap.  end() ) { return typeMap.  end(); }
+        auto begin() const -> decltype( typeMap.begin() ) { return typeMap.begin(); }
+        auto   end() const -> decltype( typeMap.  end() ) { return typeMap.  end(); }
 
 };
@@ -144 +145 @@
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
-                                        typeEnv[ formal ] = actual->type;
+                                        typeMap[ formal ] = actual->type;
                                 } // if
                         } else {