Changes in src/AST/TypeSubstitution.cpp [3e5dd913:361bf01]

File:

• src/AST/TypeSubstitution.cpp (modified) (10 diffs)

src/AST/TypeSubstitution.cpp

@@ -39 +39 @@
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
+        dest.varEnv.clear();
         dest.add( src );
 }
@@ -46 +47 @@
                 typeEnv[ i->first ] = i->second;
         } // for
-}
-
-void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
-        typeEnv[ *formalType ] = actualType;
-}
-
-void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
-        typeEnv[ key ] = actualType;
-}
-
-void TypeSubstitution::remove( const TypeInstType * formalType ) {
-        TypeEnvType::iterator i = typeEnv.find( *formalType );
+        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::addVar( std::string formalExpr, const Expr *actualExpr ) {
+        varEnv[ formalExpr ] = actualExpr;
+}
+
+void TypeSubstitution::remove( std::string 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 );
+                typeEnv.erase( formalType );
+        } // if
+}
+
+const Type *TypeSubstitution::lookup( std::string formalType ) const {
+        TypeEnvType::const_iterator i = typeEnv.find( formalType );
 
         // break on not in substitution set
@@ -71 +75 @@
         // 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 == *actualType ) break;
+                if ( formalType == typeName ) break;
 
                 // Look for the type this maps to, returning previous mapping if none-such
-                i = typeEnv.find( *actualType );
+                i = typeEnv.find( typeName );
                 if ( i == typeEnv.end() ) return actualType;
         }
@@ -84 +90 @@
 
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty();
+        return typeEnv.empty() && varEnv.empty();
 }
 
@@ -92 +98 @@
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( FunctionType * ftype ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
-                        for (auto & formal : ftype->forall) {
-                                if ( const Type * t = env->lookup( formal ) ) {
-                                        newEnv->add( formal, t );
-                                }
+                        if ( const Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
                         }
                 }
@@ -126 +130 @@
 
 const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( *inst );
+        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
+        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
         if ( i == sub.typeEnv.end() ) {
                 return inst;
@@ -137 +141 @@
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
                 if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
-                        if ( *inst == *replacement ) {
+                        if ( inst->name == replacement->name ) {
                                 return inst;
                         }
@@ -152 +156 @@
 }
 
+const Expr * TypeSubstitution::Substituter::postvisit( const NameExpr * nameExpr ) {
+        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
+        if ( i == sub.varEnv.end() ) {
+                return nameExpr;
+        } else {
+                subCount++;
+                return i->second;
+        } // if
+}
+
 void TypeSubstitution::Substituter::previsit( const FunctionType * ptype ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( auto & tyvar : ptype->forall ) {
-                                boundVars.insert( *tyvar );
+                for ( const TypeDecl * tyvar : ptype->forall ) {
+                                boundVars.insert( tyvar->name );
                 } // for
         } // if
 }
 
-/*
 void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
@@ -171 +184 @@
                         if ( ! type->params.empty() ) {
                                 for ( const TypeDecl * tyvar : decl->params ) {
-                                        boundVars.insert( *tyvar );
+                                        boundVars.insert( tyvar->name );
                                 } // for
                         } // if
@@ -185 +198 @@
         handleAggregateType( aggregateUseType );
 }
-*/
 
 } // namespace ast