Changeset 2a7b3ca for src/GenPoly

Timestamp:

Jun 26, 2017, 4:13:36 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

579263a, 949934e

Parents:

d24d4e1

Message:

convert InstantiateGeneric? to PassVisitor?, add missing mutate and accept calls to PassVisitor?, add missing ValueGuardPtrs? to PassVisitor::handleStatementList

Location:

src/GenPoly

Files:

• Box.cc (modified) (4 diffs)
• InstantiateGeneric.cc (modified) (11 diffs)

src/GenPoly/Box.cc

@@ -504 +504 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
+                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
                                 doBeginScope();
                                 scopeTyVars.beginScope();
@@ -548 +549 @@
                                 retval = oldRetval;
                                 doEndScope();
+                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
                         return functionDecl;
@@ -1116 +1118 @@
 
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
-                        // std::cerr << "mutate appExpr: ";
+                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
                         //      std::cerr << i->first << " ";
@@ -1141 +1143 @@
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
 
+                        // std::cerr << function << std::endl;
+                        // std::cerr << "scopeTyVars: ";
+                        // printTyVarMap( std::cerr, scopeTyVars );
+                        // std::cerr << "exprTyVars: ";
+                        // printTyVarMap( std::cerr, exprTyVars );
+                        // std::cerr << "env: " << *env << std::endl;
+                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
+
                         // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
                         // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
                         // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
                                 ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType

src/GenPoly/InstantiateGeneric.cc

@@ -22 +22 @@
 #include "InstantiateGeneric.h"
 
-#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
-#include "PolyMutator.h"
+
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
 
 #include "ResolvExpr/typeops.h"
@@ -34 +37 @@
 #include "SynTree/Type.h"
 
-#include "Common/ScopedMap.h"
-#include "Common/UniqueName.h"
-#include "Common/utility.h"
+
+#include "InitTweak/InitTweak.h"
+
 
 namespace GenPoly {
@@ -153 +156 @@
         }
 
-        // 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
-        class GenericInstantiator final : public DeclMutator {
+        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -178 +164 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-                /// 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;
+                /// 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( FunctionType * ftype ) {
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                }
+
+                void beginScope();
+                void endScope();
         private:
                 /// Wrap instantiation lookup for structs
@@ -207 +196 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                EnvFinder finder;
-                mutateAll( translationUnit, finder );
-                GenericInstantiator instantiator( finder.envMap );
-                instantiator.mutateDeclarationList( translationUnit );
+                PassVisitor<GenericInstantiator> instantiator;
+                mutateAll( translationUnit, instantiator );
         }
 
@@ -306 +293 @@
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( envMap.count( typeInst ) ) {
-                                TypeSubstitution * env = envMap.at( typeInst );
+                        if ( env && ! inFunctionType ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
@@ -331 +317 @@
 
 
-        Type* GenericInstantiator::mutate( StructInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< StructInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -368 +349 @@
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -388 +369 @@
         }
 
-        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< UnionInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -423 +399 @@
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -442 +418 @@
         }
 
-        void GenericInstantiator::doBeginScope() {
-                DeclMutator::doBeginScope();
+        void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
         }
 
-        void GenericInstantiator::doEndScope() {
-                DeclMutator::doEndScope();
+        void GenericInstantiator::endScope() {
                 instantiations.endScope();
                 dtypeStatics.endScope();