Changeset 90152a4 for src/SynTree/TypeSubstitution.h

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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 cleanup-dtors

File:

• src/SynTree/TypeSubstitution.h (modified) (7 diffs)

src/SynTree/TypeSubstitution.h

@@ -27 +27 @@
 #include "SynTree/Declaration.h"   // for TypeDecl, Declaration (ptr only)
 #include "SynTree/Expression.h"    // for Expression (ptr only), NameExpr (p...
-#include "SynTree/Mutator.h"       // for Mutator
 #include "SynTree/Type.h"          // for Type, ArrayType (ptr only), BasicT...
 
-class TypeSubstitution : public Mutator {
-        typedef Mutator Parent;
+class TypeSubstitution {
   public:
         TypeSubstitution();
@@ -57 +55 @@
         void extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result );
 
+        /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
+        static TypeSubstitution * newFromExpr( Expression * expr, TypeSubstitution * env );
+
         void normalize();
 
@@ -64 +65 @@
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
-        virtual Type* mutate(TypeInstType *aggregateUseType);
-        virtual Expression* mutate(NameExpr *nameExpr);
-
-        /// Records type variable bindings from forall-statements
-        template< typename TypeClass > Type *handleType( TypeClass *type );
-        /// Records type variable bindings from forall-statements and instantiations of generic types
-        template< typename TypeClass > Type *handleAggregateType( TypeClass *type );
-
-        virtual Type* mutate(VoidType *basicType);
-        virtual Type* mutate(BasicType *basicType);
-        virtual Type* mutate(PointerType *pointerType);
-        virtual Type* mutate(ArrayType *arrayType);
-        virtual Type* mutate(FunctionType *functionType);
-        virtual Type* mutate(StructInstType *aggregateUseType);
-        virtual Type* mutate(UnionInstType *aggregateUseType);
-        virtual Type* mutate(EnumInstType *aggregateUseType);
-        virtual Type* mutate(TraitInstType *aggregateUseType);
-        virtual Type* mutate(TupleType *tupleType);
-        virtual Type* mutate(VarArgsType *varArgsType);
-        virtual Type* mutate(ZeroType *zeroType);
-        virtual Type* mutate(OneType *oneType);
+
+        // Mutator that performs the substitution
+        struct Substituter;
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
@@ -97 +80 @@
         typedef std::map< std::string, Type* > TypeEnvType;
         typedef std::map< std::string, Expression* > VarEnvType;
-        typedef std::set< std::string > BoundVarsType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
-        BoundVarsType boundVars;
-        int subCount;
-        bool freeOnly;
+
+  public:
+        // has to come after declaration of typeEnv
+        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
 };
 
@@ -122 +108 @@
                                 } // if
                         } else {
-                                throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal );
+                                SemanticError( formal, toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ) );
                         } // if
                 } else {
@@ -134 +120 @@
 
 template< typename FormalIterator, typename ActualIterator >
-TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
-{
+TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
         add( formalBegin, formalEnd, actualBegin );
 }
+
+// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
+// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
+#include "Common/PassVisitor.h"
+
+// definitition must happen after PassVisitor is included so that WithGuards can be used
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
+                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Expression * postmutate( NameExpr * nameExpr );
+
+                /// Records type variable bindings from forall-statements
+                void premutate( Type * type );
+                /// Records type variable bindings from forall-statements and instantiations of generic types
+                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+
+                void premutate( StructInstType * aggregateUseType );
+                void premutate( UnionInstType * aggregateUseType );
+
+                TypeSubstitution & sub;
+                int subCount = 0;
+                bool freeOnly;
+                typedef std::set< std::string > BoundVarsType;
+                BoundVarsType boundVars;
+};
 
 template< typename SynTreeClass >
 int TypeSubstitution::apply( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = false;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
-        assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+        PassVisitor<Substituter> sub( *this, false );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
+        assert( input );
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 
@@ -155 +165 @@
 int TypeSubstitution::applyFree( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = true;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
-        assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+        PassVisitor<Substituter> sub( *this, true );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
+        assert( input );
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }