Changeset e9a715d3
 Timestamp:
 Jan 9, 2018, 4:03:54 PM (6 years ago)
 Branches:
 ADT, aaronthesis, armeh, astexperimental, cleanupdtors, deferred_resn, demangler, enum, forallpointerdecay, jacob/cs343translation, jenkinssandbox, master, newast, newastuniqueexpr, newenv, no_list, persistentindexer, pthreademulation, qualifiedEnum, resolvnew, with_gc
 Children:
 b8a4f47
 Parents:
 07c178f0
 Location:
 src/SynTree
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

src/SynTree/TypeSubstitution.cc
r07c178f0 re9a715d3 107 107 108 108 void TypeSubstitution::normalize() { 109 PassVisitor<Substituter> sub( *this, true ); 109 110 do { 110 sub Count = 0;111 freeOnly = true;111 sub.pass.subCount = 0; 112 sub.pass.freeOnly = true; 112 113 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) { 113 i>second = i>second>acceptMutator( *this);114 i>second = i>second>acceptMutator( sub ); 114 115 } 115 } while ( sub Count );116 } 117 118 Type * TypeSubstitution:: mutate( TypeInstType *inst ) {119 BoundVarsType::const_iterator bound = boundVars.find( inst> get_name());116 } while ( sub.pass.subCount ); 117 } 118 119 Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) { 120 BoundVarsType::const_iterator bound = boundVars.find( inst>name ); 120 121 if ( bound != boundVars.end() ) return inst; 121 122 122 TypeEnvType::const_iterator i = typeEnv.find( inst>get_name() );123 if ( i == typeEnv.end() ) {123 TypeEnvType::const_iterator i = sub.typeEnv.find( inst>get_name() ); 124 if ( i == sub.typeEnv.end() ) { 124 125 return inst; 125 126 } else { 126 /// std::c out<< "found " << inst>get_name() << ", replacing with ";127 /// i>second>print( std::c out);128 /// std::c out<< std::endl;127 /// std::cerr << "found " << inst>get_name() << ", replacing with "; 128 /// i>second>print( std::cerr ); 129 /// std::cerr << std::endl; 129 130 subCount++; 130 Type * newtype = i>second>clone();131 Type * newtype = i>second>clone(); 131 132 newtype>get_qualifiers() = inst>get_qualifiers(); 132 133 delete inst; … … 135 136 } 136 137 137 Expression * TypeSubstitution:: mutate( NameExpr *nameExpr ) {138 VarEnvType::const_iterator i = varEnv.find( nameExpr>get_name());139 if ( i == varEnv.end() ) {138 Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) { 139 VarEnvType::const_iterator i = sub.varEnv.find( nameExpr>name ); 140 if ( i == sub.varEnv.end() ) { 140 141 return nameExpr; 141 142 } else { … … 146 147 } 147 148 148 template< typename TypeClass > 149 Type *TypeSubstitution::handleType( TypeClass *type ) { 150 ValueGuard<BoundVarsType> oldBoundVars( boundVars ); 149 void TypeSubstitution::Substituter::premutate( Type * type ) { 150 GuardValue( boundVars ); 151 151 // bind type variables from forallqualifiers 152 152 if ( freeOnly ) { 153 for ( Type::ForallList::const_iterator tyvar = type> get_forall().begin(); tyvar != type>get_forall().end(); ++tyvar ) {154 boundVars.insert( (*tyvar )>get_name());153 for ( Type::ForallList::const_iterator tyvar = type>forall.begin(); tyvar != type>forall.end(); ++tyvar ) { 154 boundVars.insert( (*tyvar)>name ); 155 155 } // for 156 156 } // if 157 Type *ret = Mutator::mutate( type );158 return ret;159 157 } 160 158 161 159 template< typename TypeClass > 162 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {163 ValueGuard<BoundVarsType> oldBoundVars( boundVars );160 void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) { 161 GuardValue( boundVars ); 164 162 // bind type variables from forallqualifiers 165 163 if ( freeOnly ) { 166 for ( Type::ForallList::const_iterator tyvar = type> get_forall().begin(); tyvar != type>get_forall().end(); ++tyvar ) {167 boundVars.insert( (*tyvar )>get_name());164 for ( Type::ForallList::const_iterator tyvar = type>forall.begin(); tyvar != type>forall.end(); ++tyvar ) { 165 boundVars.insert( (*tyvar)>name ); 168 166 } // for 169 167 // bind type variables from generic type instantiations 170 168 std::list< TypeDecl* > *baseParameters = type>get_baseParameters(); 171 if ( baseParameters && ! type> get_parameters().empty() ) {169 if ( baseParameters && ! type>parameters.empty() ) { 172 170 for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters>begin(); tyvar != baseParameters>end(); ++tyvar ) { 173 boundVars.insert( (*tyvar)> get_name());171 boundVars.insert( (*tyvar)>name ); 174 172 } // for 175 173 } // if 176 174 } // if 177 Type *ret = Mutator::mutate( type ); 178 return ret; 179 } 180 181 Type * TypeSubstitution::mutate( VoidType *voidType ) { 182 return handleType( voidType ); 183 } 184 185 Type * TypeSubstitution::mutate( BasicType *basicType ) { 186 return handleType( basicType ); 187 } 188 189 Type * TypeSubstitution::mutate( PointerType *pointerType ) { 190 return handleType( pointerType ); 191 } 192 193 Type * TypeSubstitution::mutate( ArrayType *arrayType ) { 194 return handleType( arrayType ); 195 } 196 197 Type * TypeSubstitution::mutate( FunctionType *functionType ) { 198 return handleType( functionType ); 199 } 200 201 Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) { 202 return handleAggregateType( aggregateUseType ); 203 } 204 205 Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) { 206 return handleAggregateType( aggregateUseType ); 207 } 208 209 Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) { 210 return handleType( aggregateUseType ); 211 } 212 213 Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) { 214 return handleType( aggregateUseType ); 215 } 216 217 Type * TypeSubstitution::mutate( TupleType *tupleType ) { 218 return handleType( tupleType ); 219 } 220 221 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) { 222 return handleType( varArgsType ); 223 } 224 225 Type * TypeSubstitution::mutate( ZeroType *zeroType ) { 226 return handleType( zeroType ); 227 } 228 229 Type * TypeSubstitution::mutate( OneType *oneType ) { 230 return handleType( oneType ); 175 } 176 177 void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) { 178 handleAggregateType( aggregateUseType ); 179 } 180 181 void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) { 182 handleAggregateType( aggregateUseType ); 231 183 } 232 184 
src/SynTree/TypeSubstitution.h
r07c178f0 re9a715d3 27 27 #include "SynTree/Declaration.h" // for TypeDecl, Declaration (ptr only) 28 28 #include "SynTree/Expression.h" // for Expression (ptr only), NameExpr (p... 29 #include "SynTree/Mutator.h" // for Mutator30 29 #include "SynTree/Type.h" // for Type, ArrayType (ptr only), BasicT... 31 30 32 class TypeSubstitution : public Mutator { 33 typedef Mutator Parent; 31 class TypeSubstitution { 34 32 public: 35 33 TypeSubstitution(); … … 64 62 TypeSubstitution *clone() const { return new TypeSubstitution( *this ); } 65 63 private: 66 virtual Type* mutate(TypeInstType *aggregateUseType);67 virtual Expression* mutate(NameExpr *nameExpr);68 64 69 /// Records type variable bindings from forallstatements 70 template< typename TypeClass > Type *handleType( TypeClass *type ); 71 /// Records type variable bindings from forallstatements and instantiations of generic types 72 template< typename TypeClass > Type *handleAggregateType( TypeClass *type ); 73 74 virtual Type* mutate(VoidType *basicType); 75 virtual Type* mutate(BasicType *basicType); 76 virtual Type* mutate(PointerType *pointerType); 77 virtual Type* mutate(ArrayType *arrayType); 78 virtual Type* mutate(FunctionType *functionType); 79 virtual Type* mutate(StructInstType *aggregateUseType); 80 virtual Type* mutate(UnionInstType *aggregateUseType); 81 virtual Type* mutate(EnumInstType *aggregateUseType); 82 virtual Type* mutate(TraitInstType *aggregateUseType); 83 virtual Type* mutate(TupleType *tupleType); 84 virtual Type* mutate(VarArgsType *varArgsType); 85 virtual Type* mutate(ZeroType *zeroType); 86 virtual Type* mutate(OneType *oneType); 65 // Mutator that performs the substitution 66 struct Substituter; 87 67 88 68 // TODO: worry about traversing into a forallqualified function type or type decl with assertions … … 97 77 typedef std::map< std::string, Type* > TypeEnvType; 98 78 typedef std::map< std::string, Expression* > VarEnvType; 99 typedef std::set< std::string > BoundVarsType;100 79 TypeEnvType typeEnv; 101 80 VarEnvType varEnv; 102 BoundVarsType boundVars;103 int subCount;104 bool freeOnly;105 81 }; 106 82 … … 134 110 135 111 template< typename FormalIterator, typename ActualIterator > 136 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) 137 { 112 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) { 138 113 add( formalBegin, formalEnd, actualBegin ); 139 114 } 115 116 // include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and 117 // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals. 118 #include "Common/PassVisitor.h" 119 120 // definitition must happen after PassVisitor is included so that WithGuards can be used 121 struct TypeSubstitution::Substituter : public WithGuards { 122 Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {} 123 124 Type * postmutate( TypeInstType * aggregateUseType ); 125 Expression * postmutate( NameExpr * nameExpr ); 126 127 /// Records type variable bindings from forallstatements 128 void premutate( Type * type ); 129 /// Records type variable bindings from forallstatements and instantiations of generic types 130 template< typename TypeClass > void handleAggregateType( TypeClass * type ); 131 132 void premutate( StructInstType * aggregateUseType ); 133 void premutate( UnionInstType * aggregateUseType ); 134 135 TypeSubstitution & sub; 136 int subCount = 0; 137 bool freeOnly; 138 typedef std::set< std::string > BoundVarsType; 139 BoundVarsType boundVars; 140 }; 140 141 141 142 template< typename SynTreeClass > 142 143 int TypeSubstitution::apply( SynTreeClass *&input ) { 143 144 assert( input ); 144 subCount = 0; 145 freeOnly = false; 146 input = dynamic_cast< SynTreeClass *>( input>acceptMutator( *this ) ); 145 PassVisitor<Substituter> sub( *this, false ); 146 input = dynamic_cast< SynTreeClass * >( input>acceptMutator( sub ) ); 147 147 assert( input ); 148 /// std::c out<< "substitution result is: ";149 /// newType>print( std::c out);150 /// std::c out<< std::endl;151 return sub Count;148 /// std::cerr << "substitution result is: "; 149 /// newType>print( std::cerr ); 150 /// std::cerr << std::endl; 151 return sub.pass.subCount; 152 152 } 153 153 … … 155 155 int TypeSubstitution::applyFree( SynTreeClass *&input ) { 156 156 assert( input ); 157 subCount = 0; 158 freeOnly = true; 159 input = dynamic_cast< SynTreeClass *>( input>acceptMutator( *this ) ); 157 PassVisitor<Substituter> sub( *this, true ); 158 input = dynamic_cast< SynTreeClass * >( input>acceptMutator( sub ) ); 160 159 assert( input ); 161 /// std::c out<< "substitution result is: ";162 /// newType>print( std::c out);163 /// std::c out<< std::endl;164 return sub Count;160 /// std::cerr << "substitution result is: "; 161 /// newType>print( std::cerr ); 162 /// std::cerr << std::endl; 163 return sub.pass.subCount; 165 164 } 166 165
Note: See TracChangeset
for help on using the changeset viewer.