Changes in src/GenPoly/InstantiateGeneric.cc [9ff56e7:c7a3081]

File:

• src/GenPoly/InstantiateGeneric.cc (modified) (10 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -22 +22 @@
 #include "InstantiateGeneric.h"
 
+#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
-
-#include "Common/PassVisitor.h"
+#include "PolyMutator.h"
+
+#include "ResolvExpr/typeops.h"
+
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Type.h"
+
 #include "Common/ScopedMap.h"
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
-
-#include "ResolvExpr/typeops.h"
-
-#include "SynTree/Declaration.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Type.h"
-
-
-#include "InitTweak/InitTweak.h"
-
 
 namespace GenPoly {
@@ -156 +153 @@
         }
 
+        // collect the environments of each TypeInstType so that type variables can be replaced
+        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
+        class EnvFinder final : public GenPoly::PolyMutator {
+        public:
+                using GenPoly::PolyMutator::mutate;
+                virtual Type * mutate( TypeInstType * inst ) override {
+                        if ( env ) envMap[inst] = env;
+                        return inst;
+                }
+
+                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
+                virtual Type * mutate( FunctionType * ftype ) override {
+                        return ftype;
+                }
+                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
+        };
+
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
+        class GenericInstantiator final : public DeclMutator {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -164 +178 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-                /// Should not make use of type environment to replace types of function parameter and return values.
-                bool inFunctionType = false;
-                GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
-
-                Type* postmutate( StructInstType *inst );
-                Type* postmutate( UnionInstType *inst );
-
-                void premutate( __attribute__((unused)) FunctionType * ftype ) {
-                        GuardValue( inFunctionType );
-                        inFunctionType = true;
-                }
-
-                void beginScope();
-                void endScope();
+                /// Reference to mapping of environments
+                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
+        public:
+                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
+
+                using DeclMutator::mutate;
+                virtual Type* mutate( StructInstType *inst ) override;
+                virtual Type* mutate( UnionInstType *inst ) override;
+
+                virtual void doBeginScope() override;
+                virtual void doEndScope() override;
         private:
                 /// Wrap instantiation lookup for structs
@@ -196 +207 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                PassVisitor<GenericInstantiator> instantiator;
-                mutateAll( translationUnit, instantiator );
+                EnvFinder finder;
+                mutateAll( translationUnit, finder );
+                GenericInstantiator instantiator( finder.envMap );
+                instantiator.mutateDeclarationList( translationUnit );
         }
 
@@ -293 +306 @@
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( env && ! inFunctionType ) {
+                        if ( envMap.count( typeInst ) ) {
+                                TypeSubstitution * env = envMap.at( typeInst );
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
@@ -317 +331 @@
 
 
-        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
+        Type* GenericInstantiator::mutate( StructInstType *inst ) {
+                // mutate subtypes
+                Type *mutated = Mutator::mutate( inst );
+                inst = dynamic_cast< StructInstType* >( mutated );
+                if ( ! inst ) return mutated;
+
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -349 +368 @@
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
-                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *this ); // recursively instantiate members
+                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -369 +388 @@
         }
 
-        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
+        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
+                // mutate subtypes
+                Type *mutated = Mutator::mutate( inst );
+                inst = dynamic_cast< UnionInstType* >( mutated );
+                if ( ! inst ) return mutated;
+
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -399 +423 @@
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
-                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *this ); // recursively instantiate members
+                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -418 +442 @@
         }
 
-        void GenericInstantiator::beginScope() {
+        void GenericInstantiator::doBeginScope() {
+                DeclMutator::doBeginScope();
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
         }
 
-        void GenericInstantiator::endScope() {
+        void GenericInstantiator::doEndScope() {
+                DeclMutator::doEndScope();
                 instantiations.endScope();
                 dtypeStatics.endScope();