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

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 );
 }
@@ -47 +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
@@ -75 +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;
         }
@@ -90 +84 @@
 
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty() && varEnv.empty();
+        return typeEnv.empty();
 }
 
@@ -98 +92 @@
                 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 );
+                                }
                         }
                 }
@@ -130 +126 @@
 
 const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
+        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;
@@ -141 +137 @@
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
                 if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
-                        if ( inst->name == replacement->name ) {
+                        if ( *inst == *replacement ) {
                                 return inst;
                         }
@@ -156 +152 @@
 }
 
-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 ( const TypeDecl * tyvar : ptype->forall ) {
-                                boundVars.insert( tyvar->name );
+                for ( auto & tyvar : ptype->forall ) {
+                                boundVars.insert( *tyvar );
                 } // for
         } // if
 }
 
+/*
 void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
@@ -184 +171 @@
                         if ( ! type->params.empty() ) {
                                 for ( const TypeDecl * tyvar : decl->params ) {
-                                        boundVars.insert( tyvar->name );
+                                        boundVars.insert( *tyvar );
                                 } // for
                         } // if
@@ -198 +185 @@
         handleAggregateType( aggregateUseType );
 }
+*/
 
 } // namespace ast