Changeset d3aa64f1

Timestamp:

Aug 31, 2020, 6:55:22 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

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

Children:

25a1cb0, 68f0c4e

Parents:

49a980b

Message:

pure visitor interface for new ast

Location:

src

Files:

• AST/Copy.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (10 diffs)
• AST/Pass.proto.hpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (3 diffs)

src/AST/Copy.hpp

@@ -21 +21 @@
 #include "Stmt.hpp"
 #include "Type.hpp"
+#include <unordered_set>
+#include <unordered_map>
 
 namespace ast {

src/AST/Pass.hpp

@@ -266 +266 @@
 
 /// Keep track of the polymorphic const TypeSubstitution * env for the current expression
+
+/// marker to force shallow copies in pass visit
+struct PureVisitor {};
+
 struct WithConstTypeSubstitution {
         const TypeSubstitution * env = nullptr;

src/AST/Pass.impl.hpp

@@ -21 +21 @@
 
 #include "AST/TypeSubstitution.hpp"
+// #include "AST/Copy.hpp"
 
 #define VISIT_START( node ) \
@@ -57 +58 @@
 
 namespace ast {
+        template<typename node_t>
+        node_t * shallowCopy( const node_t * node );
+
         namespace __pass {
                 // Check if this is either a null pointer or a pointer to an empty container
@@ -62 +66 @@
                 static inline bool empty( T * ptr ) {
                         return !ptr || ptr->empty();
+                }
+
+                template< typename core_t, typename node_t >
+                static inline node_t* mutate(const node_t *node) {
+                        return std::is_base_of<PureVisitor, core_t>::value ? ::ast::shallowCopy(node) : ::ast::mutate(node);
                 }
 
@@ -320 +329 @@
 
                 if( __pass::differs(old_val, new_val) ) {
-                        auto new_parent = mutate(parent);
+                        // auto new_parent = mutate(parent);
+                        auto new_parent = __pass::mutate<core_t>(parent);
                         new_parent->*child = new_val;
                         parent = new_parent;
@@ -334 +344 @@
                         if ( node->forall.empty() ) return;
 
-                        node_t * mut = mutate( node );
+                        node_t * mut = __pass::mutate<core_t>( node );
                         mut->forall = subs->clone( node->forall, *this );
                         node = mut;
@@ -894 +904 @@
 
                 if(mutated) {
-                        auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->clauses = std::move( new_clauses );
                         node = n;
@@ -904 +914 @@
                         auto nval = call_accept( node->field ); \
                         if(nval != node->field ) { \
-                                auto nparent = mutate(node); \
+                                auto nparent = __pass::mutate<core_t>(node); \
                                 nparent->field = nval; \
                                 node = nparent; \
@@ -1610 +1620 @@
 
                 if(mutated) {
-                        auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->associations = std::move( new_kids );
                         node = n;
@@ -1940 +1950 @@
                         }
                         if (mutated) {
-                                auto new_node = mutate( node );
+                                auto new_node = __pass::mutate<core_t>( node );
                                 new_node->typeEnv.swap( new_map );
                                 node = new_node;
@@ -1956 +1966 @@
                         }
                         if (mutated) {
-                                auto new_node = mutate( node );
+                                auto new_node = __pass::mutate<core_t>( node );
                                 new_node->varEnv.swap( new_map );
                                 node = new_node;

src/AST/Pass.proto.hpp

@@ -22 +22 @@
 template<typename core_t>
 class Pass;
+
+struct PureVisitor;
 
 namespace __pass {

src/AST/TypeSubstitution.hpp

@@ -159 +159 @@
 
 // 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;
 
@@ -187 +187 @@
         assert( input );
         Pass<Substituter> sub( *this, false );
-        input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
+//      input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
+        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
         return { input, sub.core.subCount };
 }
@@ -195 +196 @@
         assert( input );
         Pass<Substituter> sub( *this, true );
-        input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
+//      input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
+        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
         return { input, sub.core.subCount };
 }

src/ResolvExpr/Unify.cc

@@ -767 +767 @@
                 /// If this isn't done when satifying ttype assertions, then argument lists can have
                 /// different size and structure when they should be compatible.
-                struct TtypeExpander_new : public ast::WithShortCircuiting {
+                struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor {
                         ast::TypeEnvironment & tenv;
 
@@ -793 +793 @@
                                 // TtypeExpander pass is impure (may mutate nodes in place)
                                 // need to make nodes shared to prevent accidental mutation
-                                ast::ptr<ast::DeclWithType> dc = d;
-                                dc = dc->accept( expander );
+                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
                                 auto types = flatten( dc->get_type() );
                                 for ( ast::ptr< ast::Type > & t : types ) {
@@ -1114 +1113 @@
                         ast::Pass<TtypeExpander_new> expander{ tenv };
 
-                        ast::ptr<ast::TupleType> tuplec = tuple;
-                        ast::ptr<ast::TupleType> tuple2c = tuple2;
-                        const ast::Type * flat = tuplec->accept( expander );
-                        const ast::Type * flat2 = tuple2c->accept( expander );
+                        // ast::ptr<ast::TupleType> tuplec = tuple;
+                        // ast::ptr<ast::TupleType> tuple2c = tuple2;
+                        const ast::Type * flat = tuple->accept( expander );
+                        const ast::Type * flat2 = tuple2->accept( expander );
 
                         auto types = flatten( flat );