Changeset 58fe85a for src/AST/TypeSubstitution.hpp

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into park_unpark

File:

• src/AST/TypeSubstitution.hpp (modified) (9 diffs)

src/AST/TypeSubstitution.hpp

@@ -44 +44 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
-        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
+        template< typename SynTreeClass >
+        struct ApplyResult {
+                ast::ptr<SynTreeClass> node;
+                int count;
+        };
+
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
 
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = apply(p);
-                input = p;
-                return ret;
+                auto ret = apply(p);
+                input = ret.node;
+                return ret.count;
         }
 
@@ -58 +64 @@
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = applyFree(p);
-                input = p;
-                return ret;
+                auto ret = applyFree(p);
+                input = ret.node;
+                return ret.count;
         }
 
-        void add( std::string formalType, const Type *actualType );
+        void add( const TypeInstType * formalType, const Type *actualType );
+        void add( const TypeInstType::TypeEnvKey & key, const Type *actualType );
         void add( const TypeSubstitution &other );
-        void remove( std::string formalType );
-        const Type *lookup( std::string formalType ) const;
+        void remove( const TypeInstType * formalType );
+        const Type *lookup( const TypeInstType * formalType ) const;
         bool empty() const;
-
-        void addVar( std::string formalExpr, const Expr *actualExpr );
 
         template< typename FormalIterator, typename ActualIterator >
@@ -92 +97 @@
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
 
-        template<typename pass_type>
+        template<typename core_t>
         friend class Pass;
 
-        typedef std::unordered_map< std::string, ptr<Type> > TypeEnvType;
-        typedef std::unordered_map< std::string, ptr<Expr> > VarEnvType;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
         TypeEnvType typeEnv;
-        VarEnvType varEnv;
 
   public:
@@ -107 +110 @@
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
 
-        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
-        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
 
+// this is the only place where type parameters outside a function formal may be substituted.
 template< typename FormalIterator, typename ActualIterator >
 void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
@@ -123 +123 @@
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
-                                        typeEnv[ formal->name ] = actual->type;
+                                        typeEnv[ formal ] = actual->type;
                                 } // if
                         } else {
@@ -129 +129 @@
                         } // if
                 } else {
-                        // TODO: type check the formal and actual parameters
-                        if ( (*formalIt)->name != "" ) {
-                                varEnv[ (*formalIt)->name ] = *actualIt;
-                        } // if
+                        
                 } // if
         } // for
 }
+
+
 
 template< typename FormalIterator, typename ActualIterator >
@@ -142 +141 @@
 }
 
+
 } // namespace ast
 
@@ -147 +147 @@
 // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
 #include "Pass.hpp"
+#include "Copy.hpp"
 
 namespace ast {
 
 // definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
+                static size_t traceId;
 
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
-#if TIME_TO_CONVERT_PASSES
-
-                Type * postmutate( TypeInstType * aggregateUseType );
-                Expression * postmutate( NameExpr * nameExpr );
+                const Type * postvisit( const TypeInstType * aggregateUseType );
 
                 /// Records type variable bindings from forall-statements
-                void premutate( Type * type );
+                void previsit( const FunctionType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+                // void handleAggregateType( const BaseInstType * type );
 
-                void premutate( StructInstType * aggregateUseType );
-                void premutate( UnionInstType * aggregateUseType );
-
-#endif
+                // void previsit( const StructInstType * aggregateUseType );
+                // void previsit( const UnionInstType * aggregateUseType );
 
                 const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
-                typedef std::unordered_set< std::string > BoundVarsType;
+                typedef std::unordered_set< TypeInstType::TypeEnvKey > BoundVarsType;
                 BoundVarsType boundVars;
 
@@ -179 +176 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, false );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.core.subCount };
 }
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, true );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.core.subCount };
 }