Changeset 58fe85a for src/AST/TypeSubstitution.cpp

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/AST/TypeSubstitution.cpp (modified) (9 diffs)

src/AST/TypeSubstitution.cpp

@@ -19 +19 @@
 namespace ast {
 
+
+// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
+
 TypeSubstitution::TypeSubstitution() {
 }
@@ -36 +39 @@
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
-        dest.varEnv.clear();
         dest.add( src );
 }
@@ -44 +46 @@
                 typeEnv[ i->first ] = i->second;
         } // for
-        for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
-                varEnv[ i->first ] = i->second;
-        } // for
 }
 
-void TypeSubstitution::add( std::string formalType, const Type *actualType ) {
-        typeEnv[ formalType ] = actualType;
+void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
+        typeEnv[ *formalType ] = actualType;
 }
 
-void TypeSubstitution::addVar( std::string formalExpr, const Expr *actualExpr ) {
-        varEnv[ formalExpr ] = actualExpr;
+void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
+        typeEnv[ key ] = actualType;
 }
 
-void TypeSubstitution::remove( std::string formalType ) {
-        TypeEnvType::iterator i = typeEnv.find( formalType );
+void TypeSubstitution::remove( const TypeInstType * formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( *formalType );
         if ( i != typeEnv.end() ) {
-                typeEnv.erase( formalType );
+                typeEnv.erase( *formalType );
         } // if
 }
 
-const Type *TypeSubstitution::lookup( std::string formalType ) const {
-        TypeEnvType::const_iterator i = typeEnv.find( formalType );
+const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
+        TypeEnvType::const_iterator i = typeEnv.find( *formalType );
 
         // break on not in substitution set
@@ -72 +71 @@
         // attempt to transitively follow TypeInstType links.
         while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
-                const std::string& typeName = actualType->name;
-
                 // break cycles in the transitive follow
-                if ( formalType == typeName ) break;
+                if ( *formalType == *actualType ) break;
 
                 // Look for the type this maps to, returning previous mapping if none-such
-                i = typeEnv.find( typeName );
+                i = typeEnv.find( *actualType );
                 if ( i == typeEnv.end() ) return actualType;
         }
@@ -87 +84 @@
 
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty() && varEnv.empty();
+        return typeEnv.empty();
 }
 
 namespace {
         struct EnvTrimmer {
-                ptr<TypeSubstitution> env;
+                const TypeSubstitution * env;
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( TypeDecl * tyDecl ) {
+                void previsit( FunctionType * ftype ) {
                         // transfer known bindings for seen type variables
-                        if ( const Type * t = env->lookup( tyDecl->name ) ) {
-                                newEnv->add( tyDecl->name, t );
+                        for (auto & formal : ftype->forall) {
+                                if ( const Type * t = env->lookup( formal ) ) {
+                                        newEnv->add( formal, t );
+                                }
                         }
                 }
@@ -108 +107 @@
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();
-#if TIME_TO_CONVERT_PASSES
                 Pass<EnvTrimmer> trimmer( env, newEnv );
                 expr->accept( trimmer );
-#else
-                (void)expr;
-                (void)env;
-#endif
                 return newEnv;
         }
@@ -121 +115 @@
 
 void TypeSubstitution::normalize() {
-#if TIME_TO_CONVERT_PASSES
-        PassVisitor<Substituter> sub( *this, true );
+        Pass<Substituter> sub( *this, true );
         do {
-                sub.pass.subCount = 0;
-                sub.pass.freeOnly = true;
+                sub.core.subCount = 0;
+                sub.core.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                        i->second = i->second->acceptMutator( sub );
+                        i->second = i->second->accept( sub );
                 }
-        } while ( sub.pass.subCount );
-#endif
+        } while ( sub.core.subCount );
 }
 
-#if TIME_TO_CONVERT_PASSES
-
-Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
+const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
+        BoundVarsType::const_iterator bound = boundVars.find( *inst );
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
+        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
         if ( i == sub.typeEnv.end() ) {
                 return inst;
@@ -146 +136 @@
                 // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
-                if ( TypeInstType * replacement = i->second.as<TypeInstType>() ) {
-                        if ( inst->name == replacement->name ) {
+                if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
+                        if ( *inst == *replacement ) {
                                 return inst;
                         }
@@ -153 +143 @@
                 // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
-                Type * newtype = i->second->clone();
-                newtype->get_qualifiers() |= inst->get_qualifiers();
-                delete inst;
-                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
-                return newtype->acceptMutator( *visitor );
+                ptr<Type> newType = i->second; // force clone if needed
+                add_qualifiers( newType, inst->qualifiers );
+                // Note: need to recursively apply substitution to the new type because normalize does not
+                // substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
+                newType = newType->accept( *visitor );
+                return newType.release();
         } // if
 }
 
-Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
-        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
-        if ( i == sub.varEnv.end() ) {
-                return nameExpr;
-        } else {
-                subCount++;
-                delete nameExpr;
-                return i->second->clone();
-        } // if
-}
-
-void TypeSubstitution::Substituter::premutate( Type * type ) {
+void TypeSubstitution::Substituter::previsit( const FunctionType * ptype ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
+                for ( auto & tyvar : ptype->forall ) {
+                                boundVars.insert( *tyvar );
                 } // for
         } // if
 }
 
-template< typename TypeClass >
-void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
+/*
+void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
-                } // for
                 // bind type variables from generic type instantiations
-                std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
-                if ( baseParameters && ! type->parameters.empty() ) {
-                        for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
-                                boundVars.insert( (*tyvar)->name );
-                        } // for
-                } // if
+                if ( auto decl = type->aggr() ) {
+                        if ( ! type->params.empty() ) {
+                                for ( const TypeDecl * tyvar : decl->params ) {
+                                        boundVars.insert( *tyvar );
+                                } // for
+                        } // if
+                }
         } // if
 }
 
-void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
+void TypeSubstitution::Substituter::previsit( const StructInstType * aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
 
-void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
+void TypeSubstitution::Substituter::previsit( const UnionInstType *aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
-
-#endif
+*/
 
 } // namespace ast